Abstract:
A method for encoding includes encoding K blocks of information for transmission on N subchannels responsive to a number of redundant blocks M according to one of i) employing a single parity check code when the number of redundant blocks M is about 1; ii) employing a code exhibited by a code graph having one third of variable nodes are connected to one of the check nodes, another one third of variable nodes is connected to the other check node and the remaining one third of variable nodes is connected to both check nodes, when the number of redundant blocks M is 2; iii) employing a first process for determining a code for the K blocks of information, when the number of redundant blocks M is about 3 together with K blocks of information less than about 150 or the number of redundant blocks M is about 4 together with K blocks of information less than about 20; and iv) employing a second process for determining a code for the K blocks of information with redundant block M values other than for steps i), ii) and iii).

Description:
BACKGROUND OF THE INVENTION 
       [0001]    The present invention relates generally to communications, and more particularly, to an anti-jamming piecewise coding method for parallel inference channels 
       BACKGROUND OF THE INVENTION 
       [0002]    Communication systems with multiple parallel physical channels have been widely deployed. Those parallel channels are achieved in time domain, i.e., each of the packets are transmitted in a different time slot, in the frequency domain such as orthogonal-frequency-division-multiplexing (OFDM) system, in a spatial domain such as the multiple-input multiple-output (MIMO) systems, respectively. With parallel channels, high throughput or high goodput can be achieved. On the other hand, a capability of throughput of more and more users also needs to be achieved in new wireless systems. 
         [0003]    With more users, interference cannot be avoided if users share the same channels. The strong interference makes the receiver difficult to detect and decode the original messages, thus causes packet loss. Such collision between shared users on the same channel is also called jamming. Moreover, other channel impairments, e.g., deep fading, can also cause decoding failure and lead to packet loss. Another example for a parallel inference channel is a newly established cognitive radio system for reuse in the licensed spectrum in a new developing standard (IEEE 802.22). In such a system, the channels for secondary usage can be modeled as parallel channels, which suffer from strong interference from the primary users. 
         [0004]    The packet loss due to jamming decreases throughput performance significantly. Anti-jamming coding techniques are then desired for recovering the lost packets to reduce the probability of packet loss and retransmission in parallel inference channels. One solution for anti-jamming is rateless coding. However, the rateless solution is not efficient for small redundancy or when the block length is not very large. 
         [0005]    Accordingly, there is a need for an anti-jamming piecewise coding method for cognitive radio to improve the throughput efficiency with small redundancy and low complexity encoder and decoder. 
       SUMMARY OF THE INVENTION 
       [0006]    In accordance with an aspect of the invention, a method for encoding includes encoding K blocks of information for transmission on N subchannels responsive to a number of redundant blocks M according to one of i) employing a single parity check code when the number of redundant blocks M is about 1; ii) employing a code exhibited by a code graph having one third of variable nodes are connected to one of the check nodes, another one third of variable nodes is connected to the other check node and the remaining one third of variable nodes is connected to both check nodes, when the number of redundant blocks M is 2; iii) employing a first process for determining a code for the K blocks of information, when the number of redundant blocks M is about 3 together with K blocks of information less than about 150 or the number of redundant blocks M is about 4 together with K blocks of information less than about 20; and iv) employing a second process for determining a code for the K blocks of information with redundant block M values other than for steps i), ii) and iii). 
         [0007]    In accordance with another aspect of the invention, an encoder for encoding K blocks of information for transmission on N subchannels responsive to a number of redundant blocks M, comprising: i) a single parity check code when the number of redundant blocks M is about 1; ii) a code exhibited by a code graph having one third of variable nodes are connected to one of the check nodes, another one third of variable nodes is connected to the other check node and the remaining one third of variable nodes is connected to both check nodes, when the number of redundant blocks M is 2; iii) a code for the K blocks of information, when the number of redundant blocks M is about 3 together with K blocks of information less than about 150 or the number of redundant blocks M is about 4 together with K blocks of information less than about 20 determined by a first process; and iv) a code for the K blocks of information with redundant block M values other than for steps i), ii) and iii) determined according to a second process. 
         [0008]    In accordance with a further aspect of the invention, A method for encoding an anti-jamming piece-wise code comprising the steps of encoding K blocks of information for transmission on N subchannels responsive to a number of redundant blocks M according to one of i) employing a single parity check code when the number of redundant blocks M is about 1; ii) employing a code exhibited by a code graph having one third of variable nodes are connected to one of the check nodes, another one third of variable nodes is connected to the other check node and the remaining one third of variable nodes is connected to both check nodes, when the number of redundant blocks M is 2; iii) determining an error rate responsive to a jamming rate and code length N and searching through a set of code graphs and corresponding error rates to determine a desired error rate for determining a code for the K blocks of information, when the number of redundant blocks M is about 3 together with K blocks of information less than about 150 or the number of redundant blocks M is about 4 together with K blocks of information less than about 20; and iv) partitioning the nodes to several sets to form a code graph that is a particular code for determining a code for the K blocks of information with redundant block M values other than for steps i), ii) and iii). 
     
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         [0009]    These and other advantages of the invention will be apparent to those of ordinary skill in the art by reference to the following detailed description and the accompanying drawings. 
           [0010]      FIG. 1  is a block diagram of an anti-jamming piecewise coding method, in accordance with the invention. 
           [0011]      FIG. 2  is a flow diagram for determining an anti-jamming piecewise code for different code parameters, in accordance with the invention. 
           [0012]      FIG. 3  shows the method for finding optimal code parameters for M=3 redundant blocks, in accordance with the invention. 
           [0013]      FIG. 4  shows the method for finding optimal code parameters for M&gt;3 redundant blocks, in accordance with the invention. 
           [0014]      FIG. 5  shows Tanner graphs for understanding code construction in accordance with the invention. 
           [0015]      FIG. 6  shows residual graphs for the code condition M=3 redundant blocks for a short code block design in accordance with the invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0016]    ANTI-JAMMING PIECE-WISE CODING: The inventive anti-jamming coding scheme, also referred to herein as piecewise coding is shown in  FIG. 1 . Given K blocks of length-L information sequences, we pick all the first bits from the K blocks and encode them by a short linear block code C 1  to produce a length-N codeword. Similarly, we encode all the second bits from the K blocks by code C 2 , and so on. After obtaining the total L length-N codewords, we form one block of coded sequence by picking one bit per codeword. We then obtain N blocks of coded sequences and transmit them through N subchannels. Every short code C i  is a simple linear block code that can be efficiently encoded. To achieve low-complexity decoding, we use a message-passing technique for decoding C i . Moreover, since there is no interleaving between the information bits and coded bits among the L block codes, the encoding and decoding of L codes can be implemented in parallel. Thus, low-latency can be achieved. 
         [0017]    The same code C can be employed for all L codes, i.e., C 1 =C 2 = . . . =C L =C. By doing this, the implementation complexity can be further reduced, since they share the same encoder and decoder. The code C can also be a systematic code, in which case there are always K blocks information sequences in N blocks of coded bits. With systematic codes, if the lost packets cannot be recovered by this anti-jamming piecewise coding scheme, we only need to retransmit the lost information packets instead of retransmitting all KL bits. Another advantage for using the systematic code is fast response to the packet loss if decoders are not fully parallel. For example, if there is only one decoder, serial decoding has to be implemented for L codewords. When the first decoding process finishes and fails to decode all the bits, from all the failed information bits in this codeword, the receiver knows immediately which blocks are lost and need to be retransmitted even before the decoder finishes decoding all L codes since the failed bits exactly correspond to the lost packets. The code C being systematic can achieve higher throughput, lower complexity, and fast response to packet loss. With the same code C, the L codes can be encoded and decoded in parallel. 
         [0018]    It is well known that the iterative decoding is not the optimal decoding algorithm, especially for the short block codes. The performance of iterative decoding may be far away from maximal-likelihood (ML) decoding. Therefore, it is important to design the short codes with near-optimal performance for erasure channels under iterative decoding. Below, we present the design of short block codes for anti-jamming piecewise coding, in accordance with the invention. 
         [0019]    As shown by the flow diagram of  FIG. 2 , determination of an optimal anti-jamming piecewise code initially begins with values for various parameters such as K blocks of length L information, M redundant blocks, N subchannels and N-length codeword, jamming rate p and a probability of losing n packets defined by P n =p n (1−p) (N−n) . Further analysis and explanation of the derivation of the code design choices for different M block values is discussed further below. 
         [0020]    For 1 redundant block M the optimal code C is a single parity check code  1   1 =N. The code graph is defined by the set {l j  j=1 to 2 M −1}, where l j  denotes number of variable nodes connected the check nodes with indices being the 1 positions of binary expression of j. 
         [0021]    For 2 redundant blocks, M=2, the optimal solution is that l j =┌N/3┐ or └N/3┘, i.e., one third nodes are connected to one check nodes, one third are connected to the other check nodes, and the rest of one third are connected to both check nodes. 
         [0022]    For 3 redundant blocks and less than 150 information blocks, i.e., M=3 &amp; K&lt;150, or 4 redundant blocks and less than 20 information blocks, i.e., M=4 &amp; K&lt;20, the optimal solution is not universal for different information blocks, K, and jamming rates p. A re-iterative process, according to  FIG. 3  designated as Process 1 and the discussion below, is used to determine the optimal code. 
         [0023]    For more than 3 or 4 redundant blocks not fitting within the previous M and K limits, i.e., M&gt;3, or M=4 &amp; K≧20 the optimal code solution for a given K and jamming rate p is determined according to  FIG. 4  designated as Process 2 and the discussion below. 
         [0024]    SHORT BLOCK CODE DESIGN FOR ANTI-JAMMING PIECEWISE CODING: As noted above, iterative decoding is not an optimal decoding technique, especially for short block codes. Therefore, it is important to design the short codes with near-optimal performance for erasure channels under iterative decoding. We present the design of short block codes based on the code graph and residual graphs for erasures for various numbers of redundant blocks M. The code graph is defined by {l j  j=1 to 2 M −1}, where l j  denotes number of variable nodes connected the check nodes with indices being the 1 positions of binary expression of j. Given jamming rate p, we obtain P n =p n (1−p) (N−n) . 
         [0025]    a) Code design for M=1 
         [0026]    The optimal code C is the single parity check (SPC) code, l 1 =N. This solution is universal for any information blocks, K and any jamming rate p. 
         [0027]    b) Code design for M=2. 
         [0028]    The optimal solution for M=2 is that l j =┌N/3┐ or └N/3┘, i.e., one third of the nodes are connected to one check nodes, one third are connected to the other check nodes, and the rest of one third are connected to both check nodes. This solution is also universal for any information blocks, K and any jamming rate p. 
         [0029]    c) Code design for M=3 
         [0030]    The optimal solution is not universal for different information blocks, K and jamming rate p. The algorithm to find optimal code for given K and p is summarized and shown in  FIG. 2 . 
         [0000]    where 
         [0000]    
       
         
           
             
               
                 P 
                 e 
               
                
               
                 ( 
                 
                   { 
                   
                     l 
                     j 
                   
                   } 
                 
                 ) 
               
             
             = 
             
               
                 
                   
                     P 
                     2 
                   
                   ( 
                   
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         7 
                       
                        
                       
                         l 
                         j 
                         2 
                       
                     
                     - 
                     N 
                   
                   ) 
                 
                 / 
                 2 
               
               + 
               
                 
                   P 
                   3 
                 
                 [ 
                 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       7 
                     
                      
                     
                       
                         ∑ 
                         
                           k 
                           ≠ 
                           j 
                         
                       
                        
                       
                         
                           ( 
                           
                             
                               
                                 
                                   l 
                                   j 
                                 
                               
                             
                             
                               
                                 2 
                               
                             
                           
                           ) 
                         
                          
                         
                           l 
                           k 
                         
                       
                     
                   
                   + 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       7 
                     
                      
                     
                       ( 
                       
                         
                           
                             
                               l 
                               j 
                             
                           
                         
                         
                           
                             3 
                           
                         
                       
                       ) 
                     
                   
                   + 
                   
                     
                       ∑ 
                       
                         
                           ( 
                           
                             
                               j 
                               1 
                             
                             , 
                             
                               j 
                               2 
                             
                             , 
                             
                               j 
                               3 
                             
                           
                           ) 
                         
                         ∈ 
                         U 
                       
                     
                      
                     
                       
                         l 
                         
                           j 
                           1 
                         
                       
                        
                       
                         l 
                         
                           j 
                           2 
                         
                       
                        
                       
                         l 
                         
                           j 
                           3 
                         
                       
                     
                   
                 
                 ] 
               
             
           
         
       
     
         [0031]    Code design for small M&gt;3 
         [0032]    The optimal solution is difficult to obtain due to a large amount of code graphs. We then propose a simple method to construct a suboptimal code for small M&gt;3. The method for the simple design met is summarized and shown in  FIG. 3 . 
       Throughput Analysis 
       [0033]    We consider N blocks of data sequences carrying KL information bits transmitted through N parallel subchannels. Denote n as number of lost packets after demodulation and decoding. Assuming that the total jamming rate is p, the probability of losing n packets, P n , is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       P 
                       n 
                     
                     = 
                     
                       
                         ( 
                         
                           
                             
                               N 
                             
                           
                           
                             
                               n 
                             
                           
                         
                         ) 
                       
                        
                       
                         
                           
                             p 
                             n 
                           
                            
                           
                             ( 
                             
                               1 
                               - 
                               p 
                             
                             ) 
                           
                         
                         
                           N 
                           - 
                           n 
                         
                       
                     
                   
                   , 
                   
                     n 
                     = 
                     0 
                   
                   , 
                   1 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     N 
                     . 
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0034]    Denote E as the event of decoding failure. Since for n&gt;M=N−K, the frame error probability is 1, we then obtain overall frame error probability P w  for both anti-jamming coding schemes, given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                           w 
                         
                         = 
                         
                           
                             Pr 
                              
                             
                               ( 
                               
                                 n 
                                 &gt; 
                                 M 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               Pr 
                                
                               
                                 ( 
                                 
                                   E 
                                   | 
                                   
                                     n 
                                     ≤ 
                                     M 
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               Pr 
                                
                               
                                 ( 
                                 
                                   n 
                                   ≥ 
                                   M 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   M 
                                   + 
                                   1 
                                 
                               
                               N 
                             
                              
                             
                               P 
                               n 
                             
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 0 
                               
                               M 
                             
                              
                             
                               
                                 Pr 
                                  
                                 
                                   ( 
                                   
                                     E 
                                     | 
                                     n 
                                   
                                   ) 
                                 
                               
                                
                               
                                 
                                   P 
                                   n 
                                 
                                 . 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0035]    For rateless codes, denote N dec  as the received number of bits for successful decoding of KL information bits. We then have 
         [0000]        Pr ( E|n )= Pr ( N   dec &gt;( N−n ) L ).   (6) 
         [0036]    With the parameters {c,δ}, for practical rateless codes of block length k, N dec  is a random variable with a certain distribution. Denote x as the overhead ratio, i.e., 
         [0000]    
       
         
           
             x 
             = 
             
               
                 
                   
                     N 
                     dec 
                   
                   - 
                   KL 
                 
                 KL 
               
               . 
             
           
         
       
     
         [0000]    To obtain the analytical performance of rateless codes for anti-jamming, we first approximate the pdf of x using a Gaussian mixture, given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       f 
                        
                       
                         ( 
                         x 
                         ) 
                       
                     
                     = 
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         J 
                       
                        
                       
                         
                           π 
                           j 
                         
                          
                         
                           φ 
                            
                           
                             ( 
                             
                               
                                 x 
                                 ; 
                                 
                                   μ 
                                   j 
                                 
                               
                               , 
                               
                                 σ 
                                 j 
                                 2 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     
                       where 
                        
                       
                           
                       
                        
                       
                         φ 
                          
                         
                           ( 
                           
                             
                               x 
                               ; 
                               
                                 μ 
                                 j 
                               
                             
                             , 
                             
                               σ 
                               j 
                               2 
                             
                           
                           ) 
                         
                       
                     
                     = 
                     
                       
                         1 
                         
                           
                             2 
                              
                             
                               πσ 
                               j 
                               2 
                             
                           
                         
                       
                        
                       
                         
                            
                           
                             
                               - 
                               
                                 
                                   ( 
                                   
                                     x 
                                     - 
                                     
                                       μ 
                                       j 
                                     
                                   
                                   ) 
                                 
                                 2 
                               
                             
                             / 
                             
                               ( 
                               
                                 2 
                                  
                                 
                                   σ 
                                   j 
                                   2 
                                 
                               
                               ) 
                             
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Note that each component Gaussian pdf&#39;s in (7) should in fact be truncated Gaussian. However, the tail probability for x&lt;0 is very small. Gaussian pdf is then good enough for the approximation in equation (7). From equation (5) to equation (7), we then obtain the frame error probability P w  for anti-jamming rateless coding, given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       P 
                       w 
                       RL 
                     
                     = 
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             M 
                             + 
                             1 
                           
                         
                         N 
                       
                        
                       
                         
                           P 
                           n 
                         
                          
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               0 
                             
                             M 
                           
                            
                           
                             
                               P 
                               n 
                             
                              
                             
                               
                                 ∑ 
                                 
                                   j 
                                   = 
                                   1 
                                 
                                 J 
                               
                                
                               
                                 
                                   π 
                                   j 
                                 
                                  
                                 
                                   Q 
                                   ( 
                                   
                                     
                                       
                                         
                                           M 
                                           - 
                                           n 
                                         
                                         K 
                                       
                                       - 
                                       
                                         μ 
                                         j 
                                       
                                     
                                     
                                       σ 
                                       j 
                                     
                                   
                                   ) 
                                 
                               
                             
                           
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     
                       where 
                        
                       
                           
                       
                        
                       
                         Q 
                          
                         
                           ( 
                           x 
                           ) 
                         
                       
                     
                     = 
                     
                       
                         1 
                         
                           2 
                            
                           π 
                         
                       
                        
                       
                         
                           ∫ 
                           x 
                           
                             + 
                             ∞ 
                           
                         
                          
                         
                           
                              
                             
                               
                                 - 
                                 
                                   u 
                                   2 
                                 
                               
                               / 
                               2 
                             
                           
                            
                           
                             
                                
                               u 
                             
                             . 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The throughput efficiency of the anti-jamming rateless codes is then given by 
         [0000]    
       
         
           
             
               
                 
                   
                     η 
                     RL 
                   
                   = 
                   
                     
                       
                         K 
                         N 
                       
                        
                       
                         ( 
                         
                           1 
                           - 
                           
                             P 
                             W 
                             RL 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         K 
                         N 
                       
                        
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             0 
                           
                           M 
                         
                          
                         
                           
                             ∑ 
                             
                               j 
                               = 
                               1 
                             
                             J 
                           
                            
                           
                             
                               π 
                               j 
                             
                              
                             
                               
                                 Q 
                                 ( 
                                 
                                   
                                     
                                       μ 
                                       j 
                                     
                                     - 
                                     
                                       
                                         M 
                                         - 
                                         n 
                                       
                                       K 
                                     
                                   
                                   
                                     σ 
                                     j 
                                   
                                 
                                 ) 
                               
                               . 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0037]    The frame error probability for anti-jamming piecewise coding depends on the particular code structure. For small M, given the code graph or code structure, we can compute the error probability for n≦M, i.e., the second term in equation (5). Here we simply express the throughput efficiency for anti-jamming piecewise coding as 
         [0000]    
       
         
           
             
               
                 
                   
                     η 
                     PW 
                   
                   = 
                   
                     
                       K 
                       N 
                     
                      
                     
                       
                         ( 
                         
                           1 
                           - 
                           
                             P 
                             w 
                             PW 
                           
                         
                         ) 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
       Code Representation and Residual Graph 
       [0038]    A linear block code can be represented by a Tanner graph, which consists of two types of nodes—variable nodes representing the code bits and check codes representing the parity-check constraints. An edge in the graph is placed between variable node i and check node m if H mi =1 where H mi  is the entry of the parity-check matrix H. The code graph can also be specified by a set representation. We first define (2 M −1) sets of variable nodes, Ω j , j=1, . . . , 2 M −1 for an (N,K) linear block code with M=N−K. A variable node in this code, for instance, the ith bit node, belongs to the set Ω j , if it satisfies 
         [0000]    
       
         
           
             
               
                 
                   j 
                   = 
                   
                     
                       ∑ 
                       
                         m 
                         = 
                         1 
                       
                       M 
                     
                      
                     
                       
                         2 
                         
                           m 
                           - 
                           1 
                         
                       
                        
                       
                         
                           H 
                           
                             m 
                              
                             
                                 
                             
                              
                             i 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
         [0039]    It is easily seen that the set Ω j  contains all the variable nodes connected to the check nodes with the indices being the positions of 1&#39;s in the binary representation (M bits) of j. For instance, all the bit nodes in Ω 5  are connected to the first and the third check nodes since 5=(101) 2 . It is seen that to specify a code graph, we do not need to know the exact variable sets Ω j  since any nodes connected to exactly the same check nodes, i.e., all the nodes in the same set, have no difference in a code graph. Therefore, we define the code graph by the set          ={l i } j−1   2     M−1   , where l j  denotes the cardinality of set Ω j , i.e., l j =|Ω j |. We have Σ j l j =N. To simply the expression of the set {l j }, we can enumerate l j  in the increase order of j. Then we only need to present the value of l j  without specifying l j . 
         [0040]    We now explain the code construction for a given {l j } with the following example. We construct the code for the given set          ={2,3,1}. With the set presentation, we know {l 1 =2,l 2 =3,l 3 =1}, M=2, and N=l 1 +l 2 +l 3 =6, i.e, a (6,4) code. For j=1, since 1=(01)2 and l 1 =2, there are two variable nodes connected to first check nodes only. For j=2, since 2=(10) 2  and l 2 =3, then three variable nodes are connected the second check nodes. Similarly, for j=3, since we have 3=(11) 2 , l 3 =1, the last bits connected to both check nodes. The Tanner graph of this code is presented in  FIG. 5 . Another simple example also shown in  FIG. 5  is the code graph for          ={1,1,1,1,1,1,1}, which is a (7,4) Hamming code. 
         [0041]    Note that we may introduce the set Ω 0  for the variable nodes (consequently, a new element l 0  in          ) for general set representation of code graphs. The set Ω 0  means that all the information bits in Ω 0  are not connected to (or protected by) any check nodes. In this report, we exclude this case, i.e., l 0 =0. 
         [0042]    We now define the residual graph to specify the erasure nodes in the code graph. We first define the set 
         [0000]    
       
         
           
             
               Θ 
               j 
             
              
             
               = 
               Δ 
             
              
             
               
                 { 
                 
                   
                     erasurenodei 
                      
                     
                       : 
                     
                      
                     
                         
                     
                      
                     i 
                   
                   ∈ 
                   
                     Ω 
                     j 
                   
                 
                 } 
               
               . 
             
           
         
       
     
         [0000]    Denote s j =|Θ j |. Similarly as           specifying the code graph, we define the set S M,n  to represent the residual graph of n erasure nodes for M check nodes by 
         [0000]    
       
         
           
             
               S 
               
                 M 
                 , 
                 n 
               
             
              
             
               = 
               Δ 
             
              
             
               
                 { 
                 
                   s 
                   j 
                 
                 } 
               
               
                 j 
                 = 
                 1 
               
               
                 
                   2 
                   M 
                 
                 - 
                 1 
               
             
           
         
       
     
         [0000]    with Σ j s j =n, where n is the total number of erasures. Similarly, we can also enumerate the values of s j  in an increasing order of j to simplify the representations. We usually consider 0&lt;n≦M. By studying the residual graphs {s j }, we can consider the design of the short codes, i.e., design of {l j }, for anti-jamming piecewise coding. 
       Revisiting the Inventive Code Design Methods 
       [0043]    We can see for M&gt;&gt;1, the number of sets Ω j  will be extremely large, and the above representation {l j } is not an efficient way to describe the code graph. However, in this report, we consider the design of anti-jamming codes with low redundancy, i.e., design of short codes with a small M. We next present our code design method with the help of such code representation. 
         [0044]    Code Design for M=1 
         [0045]    For M=1, there is only one solution          ={l 1 =N}, i.e., all the parity bits are connected to the only parity check node, i.e., the single parity check (SPC) code. With this code graph, the only residual set is {s 1 =1}. Thus, for any single erasure, we can always recover it with the SPC constraint. If we allow the cases that some bits are not connected to any parity-check nodes, i.e., l 0 ≠0, {           1 =N} turns out to be the optimal solution. This explains why we excludes the cases of l 0 ≠0. Hence, we have Pr(E|n≦M)=0. From equation (5), the packet error rate for anti-jamming piecewise coding with M=1 is then given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                           w 
                           
                             PW 
                             1 
                           
                         
                         = 
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               
                                 M 
                                 + 
                                 1 
                               
                             
                             N 
                           
                            
                           
                             P 
                             n 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           1 
                           - 
                           
                             P 
                             0 
                           
                           - 
                           
                             P 
                             1 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           1 
                           - 
                           
                             
                               ( 
                               
                                 1 
                                 - 
                                 p 
                               
                               ) 
                             
                             N 
                           
                           - 
                           
                             N 
                              
                             
                                 
                             
                              
                             
                               
                                 
                                   p 
                                    
                                   
                                     ( 
                                     
                                       1 
                                       - 
                                       p 
                                     
                                     ) 
                                   
                                 
                                 
                                   N 
                                   - 
                                   1 
                                 
                               
                               . 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0046]    And the throughput efficiency is 
         [0000]    
       
         
           
             
               
                 
                   
                     η 
                     
                       PW 
                       1 
                     
                   
                   = 
                   
                     
                       K 
                       
                         K 
                         + 
                         1 
                       
                     
                      
                     
                       
                         ( 
                         
                           
                             P 
                             0 
                           
                           + 
                           
                             P 
                             1 
                           
                         
                         ) 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0047]    Code Design for M=2 
         [0048]    When M=2, we consider the design of          ={l 1 ,l 2 ,l 3 }. When n=1, we have three residual graphs: {1,0,0}, {0,1,0}, {0,0,1}. For any of these cases we can recover the erasure bit. Therefore, we have Pr(E|n=1)=0. This can be actually generalized to any M with the residual graphs being {s j =1,s ∀j′≠j =0}. 
         [0049]    When n=2, as shown in  FIG. 6 , residual graphs type (a) and (b) are not decodable under iterative decoding. Such residual graphs can be represented by {s j =2,s j′≠j =0}, i.e., two erasure nodes belong to the same set Ω j . For a given code {l j }, the number of the residual graphs with two erasures contained in this code is given by Σ j ( 2   i     j   ). Note that here, as well as the rest of application, we abuse the notation ( s   l ) by including ( s   l )=0 if l&lt;s. We obtain the error probability for n=2, given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Pr 
                            
                           
                             ( 
                             
                               E 
                               , 
                               
                                 n 
                                 = 
                                 2 
                               
                             
                             ) 
                           
                         
                         = 
                         
                           
                             Pr 
                              
                             
                               ( 
                               
                                 
                                   E 
                                   | 
                                   n 
                                 
                                 = 
                                 2 
                               
                               ) 
                             
                           
                            
                           
                             P 
                             2 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             ∑ 
                             
                               j 
                               = 
                               1 
                             
                             
                               
                                 2 
                                 M 
                               
                               - 
                               1 
                             
                           
                            
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       
                                         l 
                                         j 
                                       
                                     
                                   
                                   
                                     
                                       2 
                                     
                                   
                                 
                                 ) 
                               
                               / 
                               
                                 ( 
                                 
                                   
                                     
                                       N 
                                     
                                   
                                   
                                     
                                       2 
                                     
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               P 
                               2 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           
                             
                               P 
                               2 
                             
                             ( 
                             
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   3 
                                 
                                  
                                 
                                   l 
                                   j 
                                   2 
                                 
                               
                               - 
                               N 
                             
                             ) 
                           
                           
                             N 
                              
                             
                               ( 
                               
                                 N 
                                 - 
                                 1 
                               
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0000]    As aforementioned, only the second term in equation (5) depends on the code graph. Since we have Pr(E|n=1)=0, optimizing the code graph to maximize the throughput is equivalent to minimizing the error probability in (14), i.e., 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         { 
                         
                           l 
                           j 
                         
                         } 
                       
                     
                      
                     
                       
                         ∑ 
                         j 
                       
                        
                       
                         l 
                         j 
                         2 
                       
                     
                   
                   , 
                   
                     
                       s 
                       . 
                       t 
                       . 
                       
                           
                       
                        
                       
                         
                           ∑ 
                           j 
                         
                          
                         
                           l 
                           j 
                         
                       
                     
                     = 
                     
                       N 
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
           
         
       
     
         [0050]    The solution of above optimization problem for integer sets {l j } is l j =└N/3┘ or ┌N/3┐, with Σ j=1   3 l j =1. It is also seen that the optimization problem does not depends P 2  and is a general expression for N. Hence, the optimal solution for M=2 is universal for any code length and any jamming rate. The error rate and the throughput efficiency of the optimal codes for M=2 are then given, respectively, by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           P 
                           w 
                           
                             PW 
                             2 
                           
                         
                         = 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   M 
                                   + 
                                   1 
                                 
                               
                               N 
                             
                              
                             
                               P 
                               n 
                             
                           
                           + 
                           
                             
                               
                                 P 
                                 2 
                               
                               ( 
                               
                                 
                                   
                                     ∑ 
                                     j 
                                   
                                    
                                   
                                     l 
                                     j 
                                     2 
                                   
                                 
                                 - 
                                 N 
                               
                               ) 
                             
                             
                               N 
                                
                               
                                 ( 
                                 
                                   N 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             1 
                             - 
                             
                               P 
                               0 
                             
                             - 
                             
                               P 
                               1 
                             
                             - 
                             
                               
                                 P 
                                 2 
                               
                               ( 
                               
                                 1 
                                 - 
                                 
                                   
                                     
                                       
                                         ∑ 
                                         j 
                                       
                                        
                                       
                                         l 
                                         j 
                                         2 
                                       
                                     
                                     - 
                                     N 
                                   
                                   
                                     N 
                                      
                                     
                                       ( 
                                       
                                         N 
                                         - 
                                         1 
                                       
                                       ) 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       η 
                       
                         PW 
                         2 
                       
                     
                     = 
                     
                       
                         K 
                         
                           K 
                           + 
                           2 
                         
                       
                       [ 
                       
                         
                           P 
                           0 
                         
                         + 
                         
                           P 
                           1 
                         
                         + 
                         
                           
                             P 
                             2 
                           
                           ( 
                           
                             1 
                             - 
                             
                               
                                 
                                   
                                     ∑ 
                                     j 
                                   
                                    
                                   
                                     l 
                                     j 
                                     2 
                                   
                                 
                                 - 
                                 N 
                               
                               
                                 N 
                                  
                                 
                                   ( 
                                   
                                     N 
                                     - 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                           
                           ) 
                         
                       
                       ] 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0051]    Code Design for M=3 
         [0052]    When M=3, we consider the design of          ={l j } j=1   7 . Now we investigate the error probabilities for n≧M. When n=1, we have Pr(E|n=1)=0. When n=2, similarly as above discussed, we have 
         [0000]    
       
         
           
             
               
                 
                   
                     Pr 
                      
                     
                       ( 
                       
                         E 
                         , 
                         
                           n 
                           = 
                           2 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       P 
                       2 
                     
                      
                     
                       
                         
                           
                             
                               ∑ 
                               
                                 j 
                                 = 
                                 1 
                               
                               7 
                             
                              
                             
                               l 
                               j 
                               2 
                             
                           
                           - 
                           N 
                         
                         
                           N 
                            
                           
                             ( 
                             
                               N 
                               - 
                               1 
                             
                             ) 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0053]    (1) All the residual graphs for n=2, i.e., two erasures in the same set Ω j , combined with one more erasure in the set Ω j′,j′≠j , form the first type of residual graphs for n=3. The number of such residual graphs for n=3 for a given code {l j } is then Σ j Σ k≠j ( 2   l     j   )l k . 
         [0054]    (2) The second type of residual graphs have all three erasures in the same set Θ j , as shown by the graphs in  FIG. 6(   c ). The residual graphs can be represented by {s j =3,s j≠j =0} with the total number being Σ j ( 3   l     j   ) for a given code {l j }. 
         [0055]    (3) As shown in  FIG. 6(   d ), among three erasures, one is connected to two check nodes with the other two connected to these two check nodes separately. The residual graphs {s j } are {1,1,1,0,0,0,0}, {1,0,0,1,1,0,0}, and {0,1,0,0,1,0,1}, respectively. For a given code {l j }, the total number of residual graphs in this code is l 1 l 2 l 3 +l 1 l 4 l 5 +l 2 l 4 l 6 . Similarly, the residual graphs for  FIG. 6(   e ) are {1,0,0,0,0,1,1}, {0,1,0,0,1,0,1}, and {0,0,1,1,0,0,1}, respectively, with the total number of enumerations being l 1 l 6 l 7 +l 2 l 5 l 7 +l 3 l 4 l 7 . The residual graphs for  FIG. 6(   f ) are {0,0,1,0,1,0,1}, {0,0,1,0,0,1,1}, and {0,0,0,0,1,1,1}, respectively, with the total number of enumerations being l 3 l 5 l 7 +l 3 l 6 l 7 +l 5 l 6 l 7 . The residual graph for  FIG. 6(   g ) is {0,0,1,0,1,1,0} with the total number of enumerations being l 3 l 5 l 6 . 
         [0056]    Denote U as the collections of all the three indices in the products in item (3), i.e., U={(1,2,3),(1,4,5),(2,4,6),(1,6,7),(2,5,7),(3,4,7),(3,5,7),(3,6,7),(5,6,7),(3,5,6)}. 
         [0057]    The packet error probability for n=3 is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     Pr 
                      
                     
                       ( 
                       
                         E 
                         , 
                         
                           n 
                           = 
                           3 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         
                           
                             P 
                             3 
                           
                           ( 
                           
                             
                               
                                 N 
                               
                             
                             
                               
                                 3 
                               
                             
                           
                           ) 
                         
                         
                           - 
                           1 
                         
                       
                       [ 
                       
                         
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   7 
                                 
                                  
                                 
                                   
                                     ∑ 
                                     
                                       k 
                                       ≠ 
                                       j 
                                     
                                   
                                    
                                   
                                     
                                       ( 
                                       
                                         
                                           
                                             
                                               l 
                                               j 
                                             
                                           
                                         
                                         
                                           
                                             2 
                                           
                                         
                                       
                                       ) 
                                     
                                      
                                     
                                       l 
                                       k 
                                     
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 ∑ 
                                 
                                   
                                     ( 
                                     
                                       
                                         j 
                                         1 
                                       
                                       , 
                                       
                                         j 
                                         2 
                                       
                                       , 
                                       
                                         j 
                                         3 
                                       
                                     
                                     ) 
                                   
                                   ∈ 
                                   U 
                                 
                               
                                
                               
                                 
                                   l 
                                   
                                     j 
                                     1 
                                   
                                 
                                  
                                 
                                   l 
                                   
                                     j 
                                     2 
                                   
                                 
                                  
                                 
                                   l 
                                   
                                     j 
                                     3 
                                   
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0058]    We then obtain the frame error probability and the throughput efficiency for M=3 given, respectively, by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                               
                           
                            
                           
                             
                               P 
                               w 
                               
                                 PW 
                                 3 
                               
                             
                             = 
                               
                              
                             
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     
                                       M 
                                       + 
                                       1 
                                     
                                   
                                   N 
                                 
                                  
                                 
                                   P 
                                   n 
                                 
                               
                               + 
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     2 
                                   
                                   3 
                                 
                                  
                                 
                                   
                                     Pr 
                                      
                                     
                                       ( 
                                       
                                         E 
                                         | 
                                         n 
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     P 
                                     n 
                                   
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   
                                     M 
                                     + 
                                     1 
                                   
                                 
                                 N 
                               
                                
                               
                                 P 
                                 n 
                               
                             
                             + 
                             
                               
                                 P 
                                 2 
                               
                                
                               
                                 
                                   
                                     
                                       ∑ 
                                       
                                         j 
                                         = 
                                         1 
                                       
                                       7 
                                     
                                      
                                     
                                       l 
                                       j 
                                       2 
                                     
                                   
                                   - 
                                   N 
                                 
                                 
                                   N 
                                    
                                   
                                     ( 
                                     
                                       N 
                                       - 
                                       1 
                                     
                                     ) 
                                   
                                 
                               
                             
                             + 
                             
                               
                                 
                                   P 
                                   3 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       
                                         N 
                                       
                                     
                                     
                                       
                                         3 
                                       
                                     
                                   
                                   ) 
                                 
                               
                               
                                 - 
                                 1 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                             
                            
                           
                             
                               [ 
                               
                                 
                                   
                                     ∑ 
                                     
                                       j 
                                       = 
                                       1 
                                     
                                     7 
                                   
                                    
                                   
                                     
                                       ∑ 
                                       
                                         k 
                                         ≠ 
                                         j 
                                       
                                     
                                      
                                     
                                       
                                         ( 
                                         
                                           
                                             
                                               
                                                 l 
                                                 j 
                                               
                                             
                                           
                                           
                                             
                                               2 
                                             
                                           
                                         
                                         ) 
                                       
                                        
                                       
                                         l 
                                         k 
                                       
                                     
                                   
                                 
                                 + 
                                 
                                   
                                     ∑ 
                                     
                                       j 
                                       = 
                                       1 
                                     
                                     7 
                                   
                                    
                                   
                                     ( 
                                     
                                       
                                         
                                           
                                             l 
                                             j 
                                           
                                         
                                       
                                       
                                         
                                           3 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                 + 
                                 
                                   
                                     ∑ 
                                     
                                       
                                         ( 
                                         
                                           
                                             j 
                                             1 
                                           
                                           , 
                                           
                                             j 
                                             2 
                                           
                                           , 
                                           
                                             j 
                                             3 
                                           
                                         
                                         ) 
                                       
                                       ∈ 
                                       U 
                                     
                                   
                                    
                                   
                                     
                                       l 
                                       
                                         j 
                                         1 
                                       
                                     
                                      
                                     
                                       l 
                                       
                                         j 
                                         2 
                                       
                                     
                                      
                                     
                                       l 
                                       
                                         j 
                                         3 
                                       
                                     
                                   
                                 
                               
                               ] 
                             
                             , 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     η 
                     = 
                     
                       
                         P 
                         0 
                       
                       + 
                       
                         P 
                         1 
                       
                       + 
                       
                         
                           P 
                           2 
                         
                         ( 
                         
                           1 
                           - 
                           
                             
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   7 
                                 
                                  
                                 
                                   l 
                                   j 
                                   2 
                                 
                               
                               - 
                               N 
                             
                             
                               N 
                                
                               
                                 ( 
                                 
                                   N 
                                   - 
                                   1 
                                 
                                 ) 
                               
                             
                           
                         
                         ) 
                       
                       + 
                       
                         P 
                         3 
                       
                       - 
                       
                         
                           
                             
                               
                                 P 
                                 3 
                               
                                
                               
                                 ( 
                                 
                                   
                                     
                                       N 
                                     
                                   
                                   
                                     
                                       3 
                                     
                                   
                                 
                                 ) 
                               
                             
                             
                               - 
                               1 
                             
                           
                            
                           
                             [ 
                             
                               
                                 
                                   
                                     
                                       
                                         ∑ 
                                         
                                           j 
                                           = 
                                           1 
                                         
                                         7 
                                       
                                        
                                       
                                         
                                           ∑ 
                                           
                                             k 
                                             ≠ 
                                             j 
                                           
                                         
                                          
                                         
                                           
                                             ( 
                                             
                                               
                                                 
                                                   
                                                     l 
                                                     j 
                                                   
                                                 
                                               
                                               
                                                 
                                                   2 
                                                 
                                               
                                             
                                             ) 
                                           
                                            
                                           
                                             l 
                                             k 
                                           
                                         
                                       
                                     
                                     + 
                                     
                                       
                                         ∑ 
                                         
                                           j 
                                           = 
                                           1 
                                         
                                         7 
                                       
                                        
                                       
                                         ( 
                                         
                                           
                                             
                                               
                                                 l 
                                                 j 
                                               
                                             
                                           
                                           
                                             
                                               3 
                                             
                                           
                                         
                                         ) 
                                       
                                     
                                     + 
                                   
                                 
                               
                               
                                 
                                   
                                     
                                       ∑ 
                                       
                                         
                                           ( 
                                           
                                             
                                               j 
                                               1 
                                             
                                             , 
                                             
                                               j 
                                               2 
                                             
                                             , 
                                             
                                               j 
                                               3 
                                             
                                           
                                           ) 
                                         
                                         ∈ 
                                         U 
                                       
                                     
                                      
                                     
                                       
                                         l 
                                         
                                           j 
                                           1 
                                         
                                       
                                        
                                       
                                         l 
                                         
                                           j 
                                           2 
                                         
                                       
                                        
                                       
                                         l 
                                         
                                           j 
                                           3 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             ] 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0059]    To design the code to maximize the throughput efficiency, we need to find the code graph {l j } that minimizes the frame error probability, i.e., 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       min 
                       
                         { 
                         
                           l 
                           j 
                         
                         } 
                       
                     
                      
                     
                       
                         P 
                         w 
                         
                           PW 
                           3 
                         
                       
                        
                       
                           
                       
                        
                       
                         s 
                         . 
                         t 
                         . 
                         
                             
                         
                          
                         
                           
                             ∑ 
                             
                               j 
                               = 
                               1 
                             
                             7 
                           
                            
                           
                             l 
                             j 
                           
                         
                       
                     
                   
                   = 
                   
                     N 
                     . 
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
           
         
       
     
         [0060]    To solve the above optimization, we need to enumerate {l 1 }. The optimal code design process for M=3 is summarized as follows. 
         [0061]    Process 1 [Optimal design method for anti-jamming piecewise codes with M=3.] See  FIG. 3 . 
         [0000]    
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 Set code length N and jamming rate p. 
               
               
                   
                 (a) Compute P n  according to equation (4). 
               
               
                   
                 (b) Initially set P e   * . 
               
               
                   
                 For l 1  = 0, 1, . . . , N, 
               
               
                   
                 For l 2  = 0, 1, . . . , N − l 1   
               
               
                   
                 . 
               
               
                   
                 . 
               
               
                   
                 . 
               
               
                   
                   
               
               
                   
                 
                   
                     
                       
                         
                           
                             
                               
                                 
                                   
                                     For 
                                      
                                     
                                         
                                     
                                      
                                     
                                       l 
                                       6 
                                     
                                   
                                   = 
                                   0 
                                 
                                 , 
                                 1 
                                 , 
                                 
                                   . . . 
                                 
                                  
                                 
                                     
                                 
                                 , 
                                 
                                   N 
                                   - 
                                   
                                     
                                       ∑ 
                                       
                                         j 
                                         = 
                                         1 
                                       
                                       5 
                                     
                                      
                                     
                                       l 
                                       j 
                                     
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   l 
                                   7 
                                 
                                 = 
                                 
                                   N 
                                   - 
                                   
                                     
                                       ∑ 
                                       
                                         j 
                                         = 
                                         1 
                                       
                                       6 
                                     
                                      
                                     
                                       
                                         l 
                                         j 
                                       
                                       . 
                                     
                                   
                                 
                               
                             
                           
                         
                           
                       
                     
                   
                 
               
               
                   
                   
               
               
                   
                 With {l j }, compute P e ({l j }) according to equations (18) and (19). 
               
               
                   
                 If P e ({l j }) &lt; P e   * , set P e   *  = P e ({l j }),            = {l j }. 
               
               
                   
                 End of l 6 ; End of l 5 ; . . . ; End of l 1 . 
               
               
                   
                 (c) Output           . 
               
               
                   
                   
               
             
          
         
       
     
         [0062]    It can be seen that the optimum           is not a universal solution, since it depends on the code length N and the jamming rate p. However, from the optimization results, we find that for p≦0.05, the solution for a particular N does not change with p. 
         [0063]    Code Design for small M, M&gt;3 
         [0064]    We can see that as M increases, the number of residual graphs increases exponentially, as well as the enumerations of the code graph sets {l j }. It is then infeasible to perform exhaustive search to obtain the optimal codes. 
         [0065]    By examining the optimization results of M=3 for various N and p, we find that for small p, e.g., p&lt;0.05, and not a large N, e.g., N&lt;100, the l j &#39;s in the optimized code are approximately the same. The maximum difference of l j  and l k  is one. Based on this observation, we propose the following simple suboptimal code design method for small M. 
         [0066]    Process 2 [Simple design method for anti-jamming piecewise codes with small M&gt;3.] 
         [0000]                                              Set code length N .             (a) Compute L* = └N / (2 M  −1)┘, N L  = N − L(2 M  −1) , and           set l j * = L*, j = 1,...,2 M  −1 .             (b) Set t = 0 . Do the following loops until t = N L  .             For m = 1,...,M             For j = 1,...,2 M  −1             If the weight(binaryof j) = m , Then l j * = l j * + 1, t = t + 1 .             End of j ; End of m .             (c) Output            = {l j *} .                        
For M&gt;3, we do not have analytical expressions for frame error probability P w  and throughput efficiency η, and must resort to numerical simulations.
 
         [0067]    Without anti-jamming coding techniques, the systems in inference channels suffer serious throughput loss due to strong interference or deep fading. The inventive anti-jamming piecewise coding method for inference channels, and constructing short block codes for anti-jamming piecewise coding, provides significant improvement in throughput efficiency of systems in parallel inference channels. For a jamming rate p=0.01, the inventive anti-jamming coding method improves the throughput efficiency by 38% over the systems without employing anti-jamming coding. Based on evaluation studies, compared to the rateless coding, the inventive anti-jamming method can achieve 3% high throughput efficiency gain with 50% less overhead. The inventive anti-jamming coding method also enjoys extremely low-complexity encoding and decoding, and smaller decoding latency. 
         [0068]    The present invention has been shown and described in what are considered to be the most practical and preferred embodiments. It is anticipated, however, that departures may be made therefrom and that obvious modifications will be implemented by those skilled in the art. It will be appreciated that those skilled in the art will be able to devise numerous arrangements and variations, which although not explicitly shown or described herein, embody the principles of the invention and are within their spirit and scope.