Abstract:
An interleaver device configured to interleave a data set, comprising an interleaver driver, a processing unit including a data processor configured to operate as an interleaver under the control of the interleaver driver, a data input device configured to input the data set to be interleaved, and a data output device configured to output an interleaved data set. The interleaver driver includes a mapping processor configured to calculate a set of bijective elementary functions (φ n ) and to supply a mapping of the interleaver to the data processor. The interleaver driver also includes an interleaver definition generator configured to supply an interleaver definition to the mapping processor. The interleaver definition includes a compound function (φ k o . . . oφ 1 ) of at least one bijective elementary function drawn from the set of bijective elementary functions (φ n ).

Description:
FIELD OF INVENTION 
     The invention concerns an interleaver device for interleaving a data set comprising a data processor for running an interleaver under the control of driving means and an input means for inputting the data set to be interleaved and output means for outputting the interleaved data set. 
     BACKGROUND OF INVENTION 
     Such interleaver devices are specially useful in mobile telephones. 
     An interleaver is usually applied on informations transmitted on a radio channel between two radio stations. 
     In other technical fields, interleavers are also used for instance on data stored on a magnetic tape or a laser disk. 
     Turbo decoders have proved to offer near Shannon limit error protection in the case of white additive gaussian noise. One key feature of the Turbo encoder is an interleaver. 
     Interleaving data with a depth of N consists in: 
     writing N consecutive symbols of data into a buffer of size of N symbols, i th  written symbol is written at position (i−1), and then 
     read them in another order given by some permutation I of {0, . . . , N−1}. i th  read symbol is read from position I(i−1). 
     In other words if i is the original position of a symbol in an input block, then I −1 (i) is its position in the output block, where I −1  denotes the inverse permutation of I. 
     Deinterleaving data with a depth of N consists in: 
     writing N consecutive symbols of data into a buffer of size of N symbols, i th  written symbol is written at position I(i−1), and 
     then and then read them in another order given by some permutation I on {0, . . . , N−1}. i th  read symbol is read from position i−1. 
     To implement the interleaver and the deinterleaver, function is needed that provides the mapping I. With some simple permutation I, this mapping can be computed by a simple analytical formula that can be quickly evaluated on any known per se processing means. For instance if the interleaver is a rectangular interleaver with L lines and C columns, we have: 
     
       
         
           N=L·C 
         
       
     
     
       
         ∀ i ∈{0 , . . . , N −1 }I   −1 ( i )=( i  div  C )+( i  mod  C )· L   (1) 
       
     
     In this formula (x div y) stands for the quotient of x divided by y in an Euclidian division and (x mod y) stands for the remainder in the same division. 
     The way this formula is to be understood is quite simple: a rectangular interleaver consists of an array of L lines and C columns. The input data is written along the lines and read along the column. 
     If l is line number (from 0 to L−1) and c is a column number (from 0 to C−1) of some written symbol then writing along the line comes to: 
     
       
           c=i  mod  C   (2) 
       
     
     
       
           l=i  div  C   (3) 
       
     
     that is to say: 
     
       
           i=l·C+c   (4) 
       
     
     l and c are the co-ordinate of the (i+1) th  written symbol. 
     Reading along the columns comes to: 
     
       
           I   −1 ( i )= l+c·L   (5) 
       
     
     Note that as a matter of fact, equations (4) and (5) are similar when column and line roles are inverted. By substituting equations (3) and (2) in equation (5), we get equation (1) that shows that the I mapping can be obtained by simple arithmetic computations in the case of a rectangular interleaver. 
     However interleavers so simple as the rectangular interleaver do not always fit the needs of a forward error coding technique. In particular, in the case of the turbo encoding, the rectangular interleaver shows very poor performance. The interleaver to be used in the turbo encoder must be more random than the regular rectangular interleaver, and however not completely random as it must still keep some good properties of spacing interleaved symbols. 
     The simplest way to implement that kind of interleaver is to use a table where the i th  entry in the table is the value of I(i−1). The size of the table is directly derived from N, that is to say that at least s(N) bits are needed to implement the table where: 
       s ( x )= x ·┌log 2 ( x )┐  (6) 
     log 2 (x) denotes the logarithm in base two of x, and ┌x┐ denotes the ceiling of x, that is to say the least integer not less than x. When N grows bigger, then the amount of memory needed to store the table also grows bigger. 
     SUMMARY OF INVENTION 
     The aim of the invention is to provide an interleaver device which can run with very little memory to store the definition of the interleaver, even if the interleaver definition is very complex. 
     To this end, the invention relates to an interleaver device as defined in claim 1. 
     According to particular embodiments, the interleaver device may include one or more of the features defined in subclaims. 
     The invention proposes a method to build interleavers that are not so regular as the plain rectangular interleaver and nevertheless use far less memory than a completely tabulated interleaver. 
     In the case of a mobile telephone, due to real time constraint, it might be necessary to tabulate the interleaver of the invention to be able to use it, since processing the values might take too much time. However the definition can be very concise, thus holding little space in ROM. The interleaver table can held in RAM and computed off-line, during connection establishment. After call completion, the RAM can be reused for another purpose. Thus, even if the interleaver needs to be tabulated into RAM for effective use, this is all the same favourable, because the RAM can be used for something else when the call type does not need the interleaver. 
     Another advantage of having a concise definition from which a very large interleaver can be generated, is that a great variety of interleavers can be defined in the ROM memory, and only one of them selected at connection time. 
     In a particular embodiment, the interleaver definition could be transmitted over the air, as a parameter of the connection. The interleaver definition would have to follow the mobile telephone if during a hand over of the site where the interleaving is performed in the network is changed. Therefore, the next site would need to compute or select the table fast if enough during the hand over preparation time. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The invention will be understood more cleady on reading the following description, given solely by way of example and made with reference to the drawings, in which: 
     FIG. 1 is a block diagram of an interleaver device according to the invention; 
     FIG. 2 is a flow-chart showing a Mod-threshold term splitting algorithm; 
     FIG. 3 is an illustration of a term splitting function applied on a data set; 
     FIG. 4 is an illustration of a Div-mod factor split function applied on a data set; 
     FIG. 5 is an illustration of a mod-mod factor split function applied on a data set; 
     FIG. 6 is an illustration of a rectangular interleaver applied to a data set; 
     FIG. 7 is an illustration of a truncated rectangular interleaver applied to a data set; and 
     FIG. 8 is an illustration of a puncturing of an interleaver. 
    
    
     DETAILED DESCRIPTION 
     The interleaver according to the invention can be implemented on any data processing means adapted to run under the driving of a software using the splitting of the interleaver as defined hereafter. 
     For example, the interleaver can be implemented in a mobile telephone. 
     Generally, and as shown on FIG. 1, the interleaver device includes a processing unit  10 . It also includes means  12  for inputting a data set to be interleaved and means  14  for outputting the interleaved data. 
     The processing unit  10  includes a data processor  16  connected to the inputting means  12  for receiving a data set to be interleaved. It is also connected to outputting means  14  for supplying the interleaved data. 
     The data processor  16  is adapted for running an interleaved I −1 , the mapping of which is supplied by driving means  18 . The driving means  18  comprise mapping processing means  20  which are adapted to compute a mapping of the interleaver from a set of elementary bijective functions φ n  which can be derived from a Read only memory  22 . The computation is performed, according to an interleaver definition I −1  received from interfeaver definition means  24 . 
     In the present embodiment, the elementary functions are stored in the Read only memory  22 . Typically these elementary functions may be not completely defined in ROM  22 , and zero one or more additional parameters may need to be supplied for them to be operated on their argument. 
     Interleaver definition means  24 , typically consisting of a memory, are provided to supply the definition of the interleaver I −1  to mapping processing means  20 . This definition is based on the elementary functions stored in memory  22 . In particular, the interleaver I −1  is defined as a compound of the elementary functions φ n  stored in ROM  22 , along with the suitable parameters if any. The mapping processing means  20  drive the data processor  10  for it to interleave data according to the mapping which is computed by the mapping processing means  20 . This mapping is determined by performing each of the functions φ n  used to define the interleaver compounded according to the interleaver definition I −1 . 
     Typically the mapping processing means  20  compute the mapping from the definitions from ROM  22  and interleaver definition means  24  only once during connection establishment, and then keep it in a look-up table. In another embodiment, the mapping processing means  24  compute from the definition of I −1  the image I −1 (i) of the position i of a data symbol to be interleaved on the fly at every symbol. 
     The implementation of the interleaver can be easily carried out by a man skilled in the art in view of the following explanations. 
     The definition of interleavers by the inventive method is recursive. The interleaver is defined by a permutation I −1  on the set {0, 1, . . . , N−1} of the initial position indexes of the data to be interleaved. This set of position in-dexes, on which operates the interleaver I is split into a sum or a product of two smaller sets. Each of these two smaller sets can be then: 
     either permuted by the underlying index permutation of a smaller interleaver, 
     either split itself again in a sum or a product of two other smaller sets, or 
     merged with a smaller set that was produced during a previous split of set. 
     The invention allows the use of interleavers external to the invention in place of the smaller interleavers. These external interleavers can be tabulated, or computed by a processing method different from that of the invention. 
     In the description, the following notations are used. 
     Finite Elementary Set of Integer 
     For any non null positive integer x,  denotes the set: 
     
       
         ={ i/i  integer and 0 ≦i≦x −1} 
       
     
     Ellipsis Notation 
     The ellipsis ( . . . ) notation is used in the middle of a sequence instead of the full sequence. This notation does not make any assumption on the number of literals in the formal sequence using it. These convention are quite obvious and usual. Below, some instances are given:            A   1     ×   …   ×     A   p                   Shall                 be                 interpreted                 just                 as                   A   1                   if                 p     =   1               A   1     ⊕   …   ⊕       A   p                   shall                 be                 interpreted                 just                 as                   A   1                   if                 p       =   1               A   1     ⊕   …   ⊕       A   p                   shall                 be                 interpreted                 just                 as                 the                 empty                 set                 ∅                 if                 p       =   0               {     x   ,     x   +   1     ,   …              ,     y   -   1     ,   y     }                   where                 x                 and                 y                 are                 integers     ,       shall                 be                 interpreted                 just                 as                   {   x   }                   if                 x     =   y                 {     x   ,     x   +   1     ,   …              ,     y   -   1     ,   y     }                   where                 x                 and                 y                 are                 integers     ,       shall                 be                 interpreted                 the                 empty                 set                 ∅                 if                 x     &gt;   y                            
     Product of Sets 
     If A and B are two sets, then their product A×B is the set of couples (a,b) such that a is in A and b in B. In other words: 
     
       
           A×B ={( a,b )/ a∈A  and  b∈B}   
       
     
     The concept can be generalised to any finite number of sets: 
     
       
           A   1   x . . . xA   p ={( a   1   , . . . , a   p )/∀ i a   l   ∈A   l } 
       
     
     Furthermore, for the sake of simplicity, A×(B×C), or (A×B)×C will just be denoted A×B×C, since there are obvious bijections between these three sets, that is to say there is little difference between ((a,b),c), (a,(b,c)) and (a,b,c). 
     One property of the product of sets is that if A 1 , A 2 , . . . A p  are finite sets and their respective numbers of elements are denoted |A 1 |, |A 2 |, . . . |A p |, then A 1 x . . . xA p  is also finite, and its number of elements |A 1 x . . . xA p | is such that:                 A   1     ×   …   ×     A   p            =       ∏     i   =   1       i   =   p                            A   i                                   
     Union od Sets 
     The union (noted ∪) of two sets is the set of elements that are in at least one of these two sets. That is to say A∪B {x/x∈A or x∈B}. 
     Disjoint Union of Stes (Also Called Here Sun of Stes) 
     If A and B are two sets, then their sum AB is the set of couples (t,x) such that t is equal to 1 or 2 respectively when x is A or in B. 
     Consequently, AB ({1}×A)∪({2}×B). 
     1 and 2 are the usual integers and are used to distinguish the elements of A and of B in the union, so that the union is “disjoint”. 
     The concept can be generalised to any finite number of sets: 
     
       
           A   1    . . . A   p =({1 }×A   1 )∪ . . . ∪({ p}×A   p ) 
       
     
     Where 1, 2, . . . p are the usual whole numbers. 
     In the following for (t,x) in A 1  . . . A p , t is called the tag and x is called the value. 
     Furthermore, for the sake of simplicity, A(BC), and (AB)C will just be denoted ABC, since there are obvious bijections between these three sets, that is to say there is little difference between the tag sets {1, (2,1), (2,2)}, {1, (1,1), (1,2)}, and {1,2,3}. The main use of the tag is its ability to distinguish the elements according to their set of origin. 
     Note that the disjoint union is generally defined in literature such that AB=BA, that is to say there is no underlying order on the set of tags, and therefore neither are the terms ordered. However the definition is slightly modified, because this property is not desirable for this application. In the following, the expression “sum of sets” instead of “disjoint union of sets” will be used. 
     Finally, one property of the disjoint union of sets is that if A 1 , A 2 , . . . A p  are finite sets and their respective number of elements are denoted |A 1 |, |A 2 |, . . . |A p |, then A 1  . . . A p  is also finite, and its number of elements |A 1  . . . A p | is such that:                 A   1     ⊕   …   ⊕     A   p            =       ∑     i   =   1       i   =   p                            A   i                                   
     Distribution of Product of Sets Over Sun of Sets. 
     In the following it is considered that: 
     
       
           A ×( BC ) is the same as ( A×B )( A×C ) 
       
     
     As a matter of fact, there is an obvious bijection mapping the element (a,(t,v)) of A×(BC) on the element (t,(a,v)) of (A×B)(A×C). This bijection just consists in placing the tag in first position. 
     Similarly it is considered that (AB)×C is the same as (A×C)(B×C). 
     The interleaver I is built as follows. It enables a concise definition of the interleaver using several bijective elementary functions. 
     The general idea to is to build the bijection I −1 → as the compound of several bijections φ 1 , φ 2 , . . . , φ k . That is to say I −1 =φ k ° . . . °φ 2 °φ 1    
     This way we have:        ∀     n   ∈         {     1   ,     …                 k       }                     ϕ   n                     S     (     n   -   1     )         →     S     (   n   )                     With                   S     (   0   )         =       N                 and                   S     (   k   )         =     N   .                              
     This way we have:          I     -   1            :          N      N               S     (   0   )                         ϕ   1     →                     S     (   1   )                         ϕ   2     →                   …                     ϕ   k     →                     S     (   k   )                 x              ↦                  ϕ   1                     (   x   )                  ↦           ↦                  I     -   1                       (   x   )         =       ϕ   k                     (       ϕ     k   -   1                       (     …                   ϕ   2                     (       ϕ   1                     (   x   )       )        …     )       )                              
     and I −1  is so built as a compound or sequence of k simpler steps, each step consisting of a bijective function φ n . 
     One more aspect is that each intermediate set S (n)  can be defined as a sum of simpler sets T I   (n)  that are products of sets of the  form:              ∀     n   ∈       {     1   ,   …              ,   k     }                     S     (   n   )             =       T   1     (   n   )       ⊕   …   ⊕       T     q   n       (   n   )                     where        :                
            ∀     n   ∈       {     1   ,   …              ,   k     }          ∀     i   ∈       {     1   ,   …              ,     q   n       }                     T   i     (   n   )                   =       N     i   ,   1       (   n   )       ×     N     i   ,   2       (   n   )       ×   …   ×     N     i   ,     p     i   ,   n           (   n   )                                       
     and with (for all the φ n  are bijective), all the intermediate sets S (n)  having N elements:          ∀     n   ∈     {     0   ,   …              ,   k     }         ,            S     (   n   )            =         ∑     i   =   1       i   =     q   n                         (       ∏     j   =   1       j   =     p     i   ,   n                           N     i   ,   j       (   n   )         )       =   N                              
     and also q 0 =1 p 1,0 =1, N 1,1   (0) =N, q k =1, p 1,k =1 and N 1,1   (k) =N, because 
     Note that for the present application, it is needed that each φ n  be easily implementable by an algorithm that can be run on existing processing means. 
     Several types of φ n  elementary functions are defined. The different φ n  elementary functions form a set of elementary functions which are stored in memory  22 , so that their algorithm can be run by the mapping processing means  20  according to the interleaver definition I −1 . 
     Here is an introductory list of the functions that will be presented in more details later: 
     A. Functions to simplify the definitions of the other functions by putting in first position the terms or factors on which the next function is to operate: 
     Term permutation 
     Factor permutation 
     B. Functions to decompose S (n−1)  into an S (n)  with more terms or factors: 
     Elementary term split 
     Elementary factor split 
     C. Functions ensuring the equivalence between A×(BC) and (A×B)(A×C) 
     Factorisation 
     Distribution 
     D. Function to interleave a part of S (n−1)    
     Elementary interleaving: embedding of an interleaver external to the invention 
     Affine-mod: a linear relation followed by a modulus, and operating on a term of S (n−1)  as if it was a vector space whose dimension is the number of factors in this term, 
     E. Functions to simplify S (n−1)  into an S (n)  with fewer terms or factors: 
     Elementary factor merge 
     Elementary term merge 
     The different functions are as follows. 
     Term Permutation φ n    
     In that case: 
     q n =q n−1    
     σ a permutation of {1, . . . , q n }, and 
     ∀i∈{1, . . . , q n }T σ(i)   (n) =T i   (n−1)    
     φ n  is defined as:                ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                             (     t   ,   v     )         ↦         (       σ                   (   t   )       ,   v     )                                
     In the definition above t is the tag of (t,v), and v the value. 
     Example:          S     (     n   -   1     )       =       2   ×   3     ⊕     4   ×   5     ⊕   3               S     (   n   )       =     3   ⊕     4   ×   5     ⊕     2   ×   3               σ   =     (     3   ,   2   ,   1     )                            
     And for instance we have the following mappings:                ϕ   n          :             (     1   ,     (     1   ,   1     )       )         ↦         (     3   ,     (     1   ,   1     )       )                           (     3   ,     (   2   )       )         ↦         (     1   ,     (   2   )       )                           (     2   ,     (     3   ,   0     )       )         ↦         (     2   ,     (     3   ,   0     )       )                                
     Factor Permutation φ n    
     The factor permutation φ n  function permutes the factors in the product constituting the first term of S (n−1) . In fact the same principle could be used to permutes the factors of any term, but this is not needed for the definition thanks to the term permutation function defined above. 
     In that case we have: 
     q n =q n−1    
     p 1,n =p 1,n−1    
     σ a permutation of {1, . . . , p 1,n−1 } 
     ∀i∈{2, . . . , q n }=T i   (n−1)    
     ∀j∈{1, . . . , p 1,n−1}N   1,j   (n) =N 1,σ(j)   (n−1)    
     φ n  is defined as:                    ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                             x   =     (     t   ,     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )       )           ↦         {           (     1   ,     (       x     σ                   (   1   )         ,       x     σ                   (   2   )                       …                   x     σ                   (     p     1   ,     n   -   1         )             )       )               x                 otherwise                                 if                 t     =   1                          
     Example:          S     (     n   -   1     )       =       2   ×   3   ×   4     ⊕   3               S     (     n   -   1     )       =       3   ×   2   ×   4     ⊕   3                            
     σ=(2,1,3) 
     And for instance we have the following mappings:                ϕ   n          :             (     1   ,     (     1   ,   2   ,   3     )       )         ↦         (     1   ,     (     2   ,   1   ,   3     )       )                           (     2   ,     (   2   )       )         ↦         (     2   ,     (   2   )       )                           (     1   ,     (     0   ,   1   ,   2     )       )         ↦         (     1   ,     (     1   ,   0   ,   2     )       )                                
     For the term or factor permutation, φ n  is made at null processing cost. The only added value of φ n  is that it makes simpler the definitions that will follow by alleviating the notation. The following definitions are applicable to any terms or factors in a sum or product of sets, respectively, instead, thanks to the factor permutation φ n  we can without any loss of generality make them only for the first or the first and some subsequent terms or factors according to the case. 
     In consequence the permutation a is typically the compound of zero, one or two transpositions. A transposition is a permutation that swaps two elements of a set, and let the other unchanged. Thus such a permutation σ puts in the first position the terms or factors on which the next function φ n  is to operate. In other words the term or factor permutation function specifies on which term(s) or factor(s) is operating the next function in the φ k ° . . . °φ 2 °φ 1  compound. 
     Elementary Term Split φ n    
     The elementary term split function φ n  is splitting the first factor in the first term of S (n−1)  into a  sum of two sets. In fact, the same principle could be used to split any factor of any term, but this is not needed for the definition, thanks to the term and factor permutation functions defined above. An example is given on FIG.  3 . 
     S (n)  is such that from S (n−1)  to S (n) , nothing is changed except the first factor  of the first term T 1   (n−1)  that is split by a bijection f into the  sum of  of and  on which are then distributed the subsequent factors, if any, of the first term of S (n−1) . 
     In that case: 
     q n =q n−1 +1, i.e. one more term 
     ∀i∈{2, . . . , q n−1 }T i+1   (n) =T i   (n−1) , i.e. the subsequent terms unchanged 
     A and B are two positive and non null integers, and N 1,1   (n−1) =A+B, N 1,1   (n) =A and N 2,1   (n) =B 
     p 1,n =p 2,n =p 1,n−1  and ∀j∈{2, . . . , p 1,n−1 }N 1,j   (n) =N 2,j   (n) =N 1,j   (n−1)               a                 bijection           f        :             A   +   B         →         A   ⊕   B                                     x       ↦         (         t   f                     (   x   )       ,       v   f                     (   x   )         )                                
     where t f (x) and v f (x) respectively denote the tag and the value of f(x) in  
     Note that the conditions of 3 rd  and 4 th  bullets are such that:          T   1     (     n   -   1     )       =       A   +   B     ×     T   ′                 T   1     (   n   )       =     A   ×     T   ′                 T   2     (   n   )       =     B   ×     T   ′                 And                   T   ′       =       N     1   ,   2       (     n   -   1     )       ×   …   ×     N     1   ,     p     1   ,     n   -   1             (     n   -   1     )                                
     φ n  is built as:                ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                           x       ↦         {           (         t   f                     (     x   1     )       ,     (         v   f                     (     x   1     )       ,       x   2                   …                   x     p     1   ,     n   -   1               )       )             if                 t     =   1               (       t   +   1     ,   v     )         otherwise                     with         x   =     (     t   ,   v     )           and         v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                            
     The f bijections used by the elementary term split function can be defined as follows.          f        :                     A   +   B       →     A   ⊕     B                 main                 functions                              
     There are many possible functions that all are computable on any current processor. 
     As an example of f, the mod-threshold term split function will be described hereafter: 
     In this function, the modulus of an element x of  by some constant C is computed. Then it is compared to a threshold T. According to the result of this comparison, it is decided to map x either to  or to . Constants C and T are such that: 
     
       
         0 &lt;T&lt;C   
       
     
     In order to understand more easily how the mod-threshold function works, a simplified algorithm will be first presented. The simplified algorithm cannot make the mapping in a random way, but only in a sequential way, that is to say it can map element x, only after having mapped elements 0, 1, . . . , x−1 before. 
     In the simplified algorithm there are two counters nA and nB that hold the number of elements that have already been respectively mapped to  and .              n   A          :       =   0     ;                 n   B          :       =   0     ;             for                 x        :       =       0                 to                 A     +   B   -     1                 do                          begin                        if                   (       n   A     =   A     )                   then                        begin                          remark                 A                 is                 full     ,     then                 map                 x                 to                 B                              map                 x                 to                   (     2   ,     n   B       )       ;                                n   B          :       =       n   B     +   1       ;                        end                        else                 if                   (       n   B     =   B     )                   then                        begin                          remark                 B                 is                 full     ,     then                 map                 x                 to                 A                                       map                 x                 to                   (     1   ,     n   A       )                                  n   A          :       =       n   A     +   1       ;                        end                      else                      begin                          remark                 neither                 A                 or                 B                 are                 yet                 full     ,     then                 map                 x                 accord        -                 ing                 to                 threshold                 of                 modulus                            c        :       =     x                 mod                 C       ;                            if                 c     &lt;     T                 then                          begin                          map                 x                 to                   (     1   ,     n   A       )       ;                                n   A          :       =       n   A     +   1       ;                        end                      else                      begin                          map                 x                 to                   (     2   ,     n   B       )       ;                                n   B          :       =       n   B     +   1       ;                        end                      end           end                                                    
     Now, an algorithm that can work with random values of x in input (x not given in a sequential way) is presented. Three constants x M , v M  and t M  are derived from A, B, C and T according to the following definitions and formulas: 
     x M  is the greatest x while neither  nor  are yet full in the simplified algorithm above. 
     t M  is the tag of the set ( or ) not yet full after x M  has been reached by x in the simplified algorithm 
     v M  is the greatest value of the set not yet full while both sets are not yet full in the simplified algorithm. 
     x M , t M  and v M  can be alternatively defined by the following formulas:          x   M          =   Δ          max        {       x   ∈       A   +   B          /          (               l   ·   T     +   c     &lt;   A             if                 c     &lt;   T                         and                       ,       where                 l          =   Δ          x                 div                 C       ,       and                 c          =   Δ          x                 mod                 C                                    l   ·     (     C   -   T     )       +   c   -   T     &lt;   B         otherwise                     }          
          t   M              =   Δ          (             1           if                   (       (       x   M     +   1     )                   mod                 C     )       ≥   T             2       otherwise              
        if                   t   M       =       1                 then                   v   M            =   Δ          max        {       v        /          ∃     x   ≤     x   M           ,     (                 /          =   Δ          x                 div                 C               and             c        =   Δ          x                 mod                 C             ⇒       (           c   &lt;   T             and             v   =       l   ·   T     +   c             }          
        if                   t   M         =       2                 then                   v   M            =   Δ          max        {       v        /          ∃     x   ≤     x   M           ,     (               /          =   Δ          x                 div                 C               and             c        =   Δ          x                 mod                 C             ⇒     (           c   ≥   T             and             v   =       l   ·     (     C   -   T     )       +   c   -   T                     }                                                      
     Then the algorithm that maps x onto (t,v) is the following:        if                   (     x   ≤     x   M       )                   then         begin           remark                 Neither                 A                 nor                 B                 are                 yet                 full     ,     then                 discrimination                 is                 based             on                 threshold             if                   (     x                 mod                 C     )       &lt;     T                 then           begin             t        :       =   1     ;               v        :       =         (     x                 div                 C     )     ·   T     +     (     x                 mod                 C     )         ;         end       else       begin             t        :       =   2     ;               v        :       =         (     x                 div                 C     )     ·     (     C   -   T     )       +     (       (     x                 mod                 C     )     -   T     )         ;         end       end       else       begin           remark                 A                 or                 B                 is                 already                 full     ,     then                 no                 more                 discrimination     ,   the             remainder                 of                   A   +   B                   is                 mapped                 to                 the                 set                 not                 yet                 full     ,     that                 is             to                 say                 that                 with                 tag                   t   M                 t        :       =     t   M       ;               v        :       =     x   -     x   M     +     v   M         ;         end                        
     The Mod-threshold term splitting algorithm is also shown on FIG.  2 . The result of the algorithm is illustrated on FIG. 3 in the case of A=5, B=10, C=4 and T=2. 
     For some particular value to T and C the definition can be simplified. For instance when C=A+B and T=A, f is defined as:              f        :             A   +   B         →         A   ⊕   B                         x       ↦         (     t   ,   v     )                                                     with                 if                 x     &lt;   A                                                                  then                 t     =       1                 and                 v     =   x                                                                      else                 t     =       2                 and                 v     =     x   -   A                                      
     Another simplification occurs when given the values of D=A+B, C and T, A and B are chosen such that the comparison of x to x M  is not necessary, and only the comparison of the modulus to the threshold needs to be done. That is to say the mod-threshold term split function can be more simply written as:              f        :             A   +   B         →         A   ⊕   B                         x       ↦         (     t   ,   v     )                                                     with                 if                 c     &lt;   T                                                     then                 t     =       1                 and                 v     =       l   ·   T     +   c                                                         else                 t     =       2                 and                 v     =       l   ·     (     C   -   T     )       +   c   -   T                                                       where        {           c   =     x                 mod                 C                 l   =     x                 div                 C                                            
     Given D=A+B, C and T, the value of A and B for which this simplification occurs can be computed as:              {           A   =          {     x   ∈       D   /     (     x                 mod                 C     )       &lt;   T       }                      B   =          {     x   ∈       D   /     (     x                 mod                 C     )       ≥   T       }                          (   7   )                                
     where |·| denotes the number of elements in a set. 
     This can also be more simply computed as:        {           A   =     1   +       l   A     ·   T     +     c   A             where         {               I   A     =       x   A                   div                 C       ,                   c   A     =       x   A                   mod                 C       ,              and                 x   A     =     max        {     x   ∈     D   /                           (     x                 mod                 C     )     &gt;   T     }                       B   =     1   +       l   B     ·     (     C   -   T     )       +     c   B     -   T           where         {               I   B     =       x   B                   div                 C       ,                   c   B     =       x   B                   mod                 C       ,              and                 x   B     =     max        {     x   ∈     D   /                           (     x                 mod                 C     )     ≥   T     }                                             
     Finally x A  and x B  can be more simply computed by the following algorithm:          c                   :=                     (     d   -   1     )        mod                 C     ;             if                 c     &lt;     T                 then                        begin                            x   A                     :=                     (     D   -   1     )       ;                                x   B                     :=                     (     D   -   1     )       -     (     c   +   1     )       ;                        end         else                    begin                            x   B                     :=                     (     D   -   1     )       ;                                x   A                     :=                     (     D   -   1     )       -     (     c   +   1     )     +   T     ;                        end                          
     For instance D=10 C=5 T=2 will yield x B =9, x A =6, l A =1, c A =1, l B =1, c B =4, A=4 and B=6. 
     Selecting A and B such that the algorithm is simplified can result in less processing power requirement toprepare to interleaver table, or to compute the interleaver real time, or less Integrated Circuit surface, if this real time 20 term. splitting procedure is performed by an ASIC. 
     Elementary Factor Split φ n    
     The elementary factor split φ n  function is splitting the first factor in the first term of S (n−1)  into a x product of two sets. In fact the same principle could be used to split any factor of any term, but this is not needed for the definition thanks to the term and factor permutation functions defined above. 
     S (n)  is such that from S (n−1)  to S (n) , nothing is changed except the first factor  of the first term that is split by a bijection g into the x product of  and . 
     In that case: 
     q n =q n−1 , i.e. same number of terms 
     ∀i∈{2, . . . , q n−1 }T i   (n) =T i   (n−1) , i.e. the subsequent terms unchanged 
     p 1,n =p 1,n−1 +1, i.e. one more factor in first term 
     ∀j∈{2, . . . , p n−1 }N 1,j+1   (n) =N 1,j   (n−1)    
     A and B defined by AN 1   (n) , BN 2   (n) , and thus A·B=N 1   (n−1)                              a                 bijection                                     g        :                            A   ·   B           →         A   ×   B                                     x       ↦         (         g   1          (   x   )       ,       g   2          (   x   )         )                     ϕ   n                   is                 built                 as        :                     ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                           x       ↦         {           (     1   ,     (         g   1          (     x   1     )       ,       g   2          (     x   1     )       ,                   if                 t     =   1                   x   2                   …                ,       x     p     1   ,     n   -   1                   )             )                             x       otherwise                               with                                                 x   =     (     t   ,   v     )                                                   and                                                 v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                                                          
     The g bijections used by the elementary factor split function can be defined as follows:          g        :                     A   ·   B       →     A   ×   B                 main                 factor                 split                 functions                            
     There are many possible functions that all are computable on any current processor. 
     Here are some examples: 
     In the following for all x and y integer such that y&gt;0: 
     x div y stands for the quotient of Euclidian division of x by y, 
     x mod y stands for the remainder of Euclidian division of x by y. 
     Note that ∀x ∀y y&gt;0, (x mod y)∈, even for x≦0 
     The DIV-MOD factor split function:                           g        :                            A   ·   B           →         A   ×   B                         x       ↦         (       x                 div                 B     ,     x                 mod                 B       )                                
     This function is clearly bijective and: 
     
       
           g   −1 (( a,b ))= a×B+b   
       
     
     The div-mod factor split function is illustrated on FIG.  4 . 
     The MOD-MOD factor split function: 
     This function can be used only when the greatest common divider of A and B is 1 (that is to say A{circumflex over ( )}B=1).                           g        :                            A   ·   B           →         A   ×   B                         x       ↦         (       x                 mod                 A     ,     x                 mod                 B       )                                
     The fact that the greatest common divider of A and B is 1 ensures the existence of two integers A′ and B′ such that B·B′+A·A′=1. 
     This allows to build easily the inverse of g as: 
     
       
           g   −1 (( a,b ))= b+   I ((( a−b )· B ′) mod  A )· B =( a·B·B′+b·A·A ′) mod ( A·B ) 
       
     
     The mod-mod factor split function is illustrated on FIG.  5 . 
     Factorisation φ n    
     The factorisation φ n  function groups several equal terms of a sum of sets, into a product of sets. This uses the obvious bijection between:              B   ⊕   …   ⊕   B            A                 times                                    And                                A   ×   B                          
     This bijection simply maps the tag-value couple (t,v) on the value only list (t−1,v), making of the tag t an element t−1 of . 
     The factorisation φ n  thus factorises the A first terms for S (n−1) . In fact the same principle could be used to factorise any terms in S (n−1)  provided that they are equal, but this is not needed for the definition thanks to the term permutation functions defined above. 
     S (n)  and S (n−1)  are such that: 
     A is positive non null integer such that q n =q n−1 −A+1, because A terms of S (n−1)  are merged in one, 
     ∀i∈{1, . . . , A}T i   (n−1) =T 1   (n−1) , that is to say the A first terms of S (n−1)  are identical, 
     ∀i∈{2, . . . , q n }T i   (n) =T i+A−1   (n−1) , that is to say the terms following the A first terms of S (n−1)  are unaffected 
     φ n  is built as:                        ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                                       x       ↦         {           (         x   1     +   1     ,     (       x   2     ,       x   3                   …                ,     x     p     1   ,     n   -   1             )       )             if                 t     =   1               (       t   +   A   -   1     ,   v     )         otherwise                                  
        with        
          x   =     (     t   ,   v     )            
        and        
          v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                                                
     Distribution φ n    
     The distribution φ n  function does the inverse operation of the factorisation φ′n that was described in the previous section. That is to say the first factor of the first term in S (n−1)  becomes a tag for a sum. 
     In fact the same principle could be used on any factor of any term of S (n−1)  provided that the term containing that factor has at least two factors, but this is not needed for the definition thanks to the term permutation functions defined above. 
     S (n)  and S (n−1)  are such that: 
     A is a positive non null integer such that N 1,1   (n−1) =A 
     q n =q n−1 +A−1, that is to say 1 term of S (n−1)  is distributed over A terms of S (n)    
     p 1,n−1 &gt;1 (first term of S (n−1)  has at least two factors) 
     ∀i∈{1, . . . , A}p i,n =p 1,n−1 −1, the A first terms of S (n)  have one factor fewer—the one that was distributed—than the first term of S (n−1)    
     ∀i∈{1, . . . , A}∀j∈{1, . . . , p 1,n −1}N i,j   (n) =N 1,j+1   (n−1) , the A first terms of S (n)  are all identical and equal to the first term of S (n−1)  without its first factor 
     ∀i∈{2, . . . , q n−1 }T i+A−1   (n) =T i   (n−1) , the q n−1 −1 subsequent terms of S (n−1)  are un-affected 
     φ n  is built as:                        ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                                       x       ↦         {           (         x   1     +   1     ,     (       x   2     ,       x   3                   …                ,     x     p     1   ,     n   -   1             )       )             if                 t     =   1               (       t   +   A   -   1     ,   v     )         otherwise                                  
        with        
          x   =     (     t   ,   v     )            
        and        
          v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                                                
     Elementary Interleaving φ n    
     The elementary interleaving φ n  function permutes the elements of the first factor in the first term of S (n−1) . In fact the same principle could be used to permute the elements of interleave any factor of any term, but this is not needed for the definition thanks to the term and factor permutation functions defined above. 
     S (n)  and S (n−1)  are of course equal. 
     In that case: 
     S (n) =S (n−1)    
     A an integer such that A=N 1,1   (n)           •                 a                 bijection                 ι        :                   A     →   A             ϕ   n                   is                 built                 as        :                     ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                           x       ↦         {           (     1   ,     (       ι                   (     x   1     )       ,     x   2     ,   …              ,     x     p     1   ,     n   -   1             )       )             if                 t     =   1             x       otherwise                     with         x   =     (     t   ,   v     )           and         v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                            
     Here are some examples of ι bijection used by the elementary permutation function. 
     The tabulated ι function: 
     In that case the ι is implemented by a table in the memory of the processing unit. There are A entries in that table and ι(x) is written insthe (x+1) th  entry. 
     The table therefore requires s(A) bits (where s is defined in equation (6)) 
     Affine-mod φ n    
     The affine-mod φ n  function acts in the first terms of S (n−1)  as if it was a vector space of dimension p 1,n−1 . In fact the same principle could be used on any term, but this is not needed for the definition thanks to the term permutation functions defined above. 
     S (n)  and S (n−1)  are of course equal. 
     In that case: 
     S (n) =S (n−1)    
     mp 1,n−1    
     an m line m column matrix U=[u i,j ] such that ∀i∈{1, . . . , m}∀j∈{1, . . . , m}u i,j  is integer (possibly negative) 
     a m line vector V=[v i ] such that: 
     ∀i∈{1, . . . , m}v i  is integer (possibly negative) φ n  is built as:                ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                     (     t   ,   x     )     ↦     {                   (     1   ,   y     )                   if                 t     =   1                 (     t   ,   x     )                   otherwise                
                   with                 for                 t     =       1        
                   x     =         (       x   1     ,       x   2                   …                ,     x   m       )          
                   y     =         (       y   1     ,       y   2                   …                ,     y   m       )          
                   such                 that          :          
                [           z   1             ⋮             z   m           ]       =         U   ·     [           x   1             ⋮             x   m           ]       +     V        
                   and        
                     ∀     i   ∈       {     1   ,   …              ,   m     }                     y   i               =       z   i                   mod                   N   i     (   n   )                                            
     Furthermore U and V are such that the φ n  obtained be bijective. 
     One sufficient condition to be fulfilled by U and V for the affine-mod φ n  to be bijective is the following one: 
     U is the product of two matrices U (1) , and U (2) . 
     The elements of these matrices are denoted this way: ∀k∈{1,2}U (k) =[u i,j   (k) ] 
     U (1)  is a sub-diagonal matrix with a diagonal of 1 or −1, that is to say:        {             ∀       (     i   ,   j     )     ∈       {     1   ,   …              ,   m     }     2         ,         j   &gt;   i     ⇒     u     i   ,   j       (   1   )         =   0               and               ∀     i   ∈     {     1   ,   …              ,   m     }         ,       u     i   ,   i       (   1   )       =       1                 or                   u     i   ,   j       (   1   )         =     -   1                                           
     U (2)  is a diagonal matrix with for all i, i th  diagonal element primary with N 1,i   (n) , 
     That is to say:        {             ∀       (     i   ,   j     )     ∈       {     1   ,   …              ,   m     }     2         ,         j   ≠   i     ⇒     u     i   ,   j       (   2   )         =   0               and               ∀     i   ∈     {     1   ,   …              ,   m     }         ,       u     i   ,   i       (   2   )                     and                   N     1   ,   i       (   n   )                     greatest                 common                 divider                 is                 1                                       
     Product is done in this order: U=U (2) ·U (1)    
     Note: U (1)  can be also super-diagonal (elements under diagonal are null) instead of sub-diagonal, this comes up to the same thanks to the factor permutation φ n  function. 
     Annexe on Affine-mod Functions 
     Here is given a proof of the sufficient condition that was given to build the affine-mod φ n  functions. Let us recall the definition of the affine-mod function where we have omitted the n index that brings no information here, and we have replaced it by a U index, meaning that this is the φ that is generated by some matrix U. For alleviating the notation we have also omitted the term index (specifying that we are working on the first term of S (n−1) ).                ϕ   U          :               N   1     ×     N   2     ×   …   ×     N   p           →           N   1     ×     N   2     ×   …   ×     N   p                     (       x   1     ,       x   2                   …                   x   p         )     ↦     (       y   1     ,       y   2                   …                   y   p         )                            such                 that          :          
                [           z   1             ⋮             z   m           ]       =         U   ·     [           x   1             ⋮             x   p           ]       +     V        
                   and        
                     ∀     i   ∈       {     1   ,   …              ,   p     }                     y   i               =       z   i                   mod                   N   i                                  
     Since the from and to sets are the same and are finite, it is cleady necessary and sufficient to show that φ U  is injective in order to show that φ U  is bijective. 
     Let Z denote the set of signed integers, then bijectivity of φ U  is equivalent to the injectivity definition, i.e.:                  ∀       (       q   1     ,       q   2                   …                   q   p         )     ∈     Z   p                   ∀       (       x   1     ,       x   2                   …                   x   p         )     ∈       N   1     ×     N   2     ×   …   ×     N   p                     ∀       (       y   1     ,       y   2                   …                   y   p         )     ∈       N   1     ×     N   2     ×   …   ×     N   p                 }     ,         U   ·     [           x   1             ⋮             x   p           ]       +   V     =           U   ·     [           y   1             ⋮             y   p           ]       +   V   +     [             q   1     ·     N   1               ⋮               q   p     ·     N   p             ]       ⇒     [           x   1             ⋮             x   p           ]       =     [           y   1             ⋮             y   p           ]                                
     Then by a simple subtraction, by using linearity of U, and by making some variable change on x i −y i  it comes that bijectivity of φ U  is equivalent to                  ∀       (       q   1     ,       q   2                   …                   q   p         )     ∈     Z   p                   ∀       (       x   1     ,       x   2                   …                   x   p         )     ∈       [         -     N   1       +   1     ,       N   1     -   1       ]     ×   …   ×     [         -     N   p       +   1     ,       N   p     -   1       ]                 }     ,       U   ·     [           x   1             ⋮             x   p           ]       =         [             q   1     ·     N   1               ⋮               q   p     ·     N   p             ]     ⇒     [           x   1             ⋮             x   p           ]       =     [         0           ⋮           0         ]                                
     Where in the equation above all [a,b] denotes an interval of signed integers comprised between a and b inclusive. 
     Now let us assume that U is a sub-diagonal matrix, with a diagonal of 1 or −1, that is to say:        {             ∀       (     i   ,   j     )     ∈       {     1   ,   …              ,   m     }     2         ,               j   &gt;   i     ⇒     u     i   ,   j         =   0             and                           ∀     i   ∈     {     1   ,   …              ,   m     }         ,             u     i   ,   i       =       1                 or                   u   ij       =     -   1                                      
     (with of course all the elements of U integers). 
     If such a condition is fuilfilled then U is clearly inversible and the inverse U −1  of U is also a sub-diagonal matrix with a diagonal of 1 or −1 and all elements still integers. This is trivially derived by the Gauss pivot algorithm applied to inverse matrix U. 
     The equation          U   ·     [           x   1             ·           ·             x   p           ]       =     [             q   1     ·     N   1               ·           ·               q   p     ·     N   p             ]                            
     can be written:          [           x   1             ·           ·             x   p           ]     =       U     -   1       ·     [             q   1     ·     N   1               ·           ·               q   p     ·     N   p             ]                              
     Let us denote u′ i,j  the elements of U −1 =[u′ i,j ] 
     U −1  is a subdiagonal matrix with all element integer and a diagonal of 1 or −1. 
     Then by recurrence: 
     x 1  is clearly null, because x 1 =u′ 1,1   − ·q 1 ·N 1 , q 1  and u′ 1,1  are integer, and 0 is the only multiple N 1  in [−N 1 +1, N 1 −1] 
     Now for all j with 1≦j&lt;p, if ∀i 1≦i≦j, x i =0, then we have x j+1 =u′ j+1,j+1 ·q j+1 ·N j+1 , and similarly we can deduce that x j+1  is also null. 
     Now let us assume that U=U (2) ·U (1) , where U (1)  is a subdiagonal matrix with all elements integers and a diagonal of 1 or −1, and U (2)  is a diagonal matrix whose for all i, i th  diagonal element is primary with N i . 
     Let us assume that for some (q 1 , . . . , q p ) integers, and for some (x 1 , . . . , x p ) in [−N 1 +1, N 1 −1]x . . . x[−N p +1, N p −1] we have:          U   ·     [           x   1             ·           ·             x   p           ]       =     [             q   1     ·     N   1               ·           ·               q   p     ·     N   p             ]                            
     Let us call          [           y   1             ·           ·             y   p           ]     =       U     (   1   )       ·     [           x   1             ·           ·             x   p           ]                              
     we have therefore:            U     (   2   )       ·     [           y   1             ·           ·             y   p           ]       =     [             q   1     ·     N   1               ·           ·               q   p     ·     N   p             ]                            
     That is to say:          [             u     1   ,   1       (   2   )       ·     y   1               ·           ·               u     p   ,   p       (   2   )       ·     y   p             ]     =     [             q   1     ·     N   1               ·           ·               q   p     ·     N   p             ]                            
     For all i from 1 to m, N i  divides u i,i   (2) ·y i , and is primary with u i,i   (2)  by definition of U (2) , then, according to Gauss theorem, it also divides y i . In other word we can find some q 1 ′, . . . , q p ′ integers such that:          [           y   1             ·           ·             y   p           ]     =     [             q   1   ′     ·     N   1               ·           ·               q   p   ′     ·     N   p             ]                            
     that is to say:            U     (   1   )       ·     [           x   1             ·           ·             x   p           ]       =     [             q   1   ′     ·     N   1               ·           ·               q   p   ′     ·     N   p             ]                            
     Now U (1)  is a sub-diagonal matrix of integers with diagonal elements all equal to 1 or to −1. Then, as we have already shown it above, this in-volves that            [           x   1             ·           ·             x   p           ]     =   0     ,                          
     and since (q 1 , . . . , q p ) were any integers, and (x 1 , . . . , x p ) any elements of [−N 1 +1, N 1 −1]x . . . x[−N p +1, N p −1], this involves that φ U  is injective, and therefore bijective, thus concluding the proof. 
     Elementary Factor Merge φ n    
     In order to get back to S (k) = in the end, some x product of sets must also sometimes be merged. The elementary factor merge φ n  function merges the two first factors of the first term of S (n−1) . In fact the same principle could be used on any pair of factors of any term that have at least two factors, but this is not needed for the definition thanks to the term and factor permutation functions defined above. 
     In that case: 
     q n =q n−1 , i.e. same number of terms 
     p 1,n−1 ≧2 and p 1,n =p 1,n−1 −1 i.e. one factor fewer in first term 
     ∀i∈{2, . . . , q n }T i   (n) =T i   (n−1) , i.e. terms other than the first one are unchanged 
     ∀j∈{3, . . . , p 1,n−1 }N 1,j−1   (n) =N 1,j   (n−1) , i.e. the p 1,n−1 −2 last factors of T 1   (n−1)  are unaffected 
     A and B defined by AN 1,1   (n−1) , BN 1,2   (n−1) , and thus A·B=N 1,1   (n)   
     a bijection              h        :                          A   ×   B           →         A   ·   B                           (       x   1     ,     x   2       )         ↦         h        (     (       x   1     ,     x   2       )     )                                  
     φ n  is built as:                ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                           x       ↦         {           (     1   ,     (       h        (       x   1     ,     x   2       )       ,       x   3                   …                ,     x     p     1   ,     n   -   1             )       )             if                 t     =   1             x       otherwise                               with                                                 x   =     (     t   ,   v     )                                                   and                                                 v   =                                                   (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                                                        
     The h bijections used by the elementary merge function can be defined as follows:          h        :                   A   ×   B     →       A   ·   B                   MAIN                 FACTOR                 MERGE                 FUNCTIONS                            
     There are many possible functions that all are computable on any current processor. 
     Here is one example: 
     In the following for all x and y integer such that y&gt;0: 
     x div y stands for the quotient of Euclidian division of x by y, 
     x mod y stands for the remainder of Euclidian division of x by y. 
     Note that ∀x ∀y y&gt;0, (x mod y)∈, even for x≦0 
     The DIV-MOD factor merge function:              h        :             A   ×   B         →         A   ·   B                           (       x   1     ,     x   2       )         ↦           B   ·     x   1       +     x   2                                  
     This function is clearly bijective and its inverse function is the div-mod factor split g bijection exemplified in the definition of the elementary factor split φ n  function: 
     Note: it is not needed to define a mod-mod factor merge h function that would be the inverse of the mod-mod factor split g function defined for the elementary factor split φ n , that is to say: 
     
       
           g ( x )=( x  mod  A, x  mod  B ) 
       
     
     
       
         g −1 (( a,b ))= b +((( a−b )· B ′) mod  A )· B   
       
     
     As a matter of fact the φ n  that would result from this mod-mod factor merge h would be the composition of an affine-mod φ n  of matrix defined by block:        U   =         [                                                                         Id                     O   v                                                                               O   H                             B   ′         0           0       1               ]            U     (   2   )           ·       [                                                                         Id                     O   v                                                                               O   H                           1         -   1             0       1               ]            U     (   1   )                                    
     and of null vector V, and of the elementary factor merge function using the div-mod factor merge h function. 
     Above Id, O V , and O H  are respectively the identity (m−2)×(m−2) matrix (diagonal of 1), the null (m−2)×2 matrix and the null 2×(m−2) matrix. 
     Elementary Term Merge φ n    
     In order to get back to  in the end, some  sum of sets must also sometimes be merged. The elementary term merge φ n  function merges the two first factors respectively of the two first terms of S (n−1) , when the two first terms have the same subsequent factors, that can therefore be factorised. In fact the same principle could be used on any pair of factor of any pair of terms in S (n−1) , provided that they can be factorised in the form          (     A   ⊕   B     )     ×     A   1     ×   …   ×       A   p     .                            
     In that case: 
     q n−1 ≧2 and q n =q n−1 −1, i.e. one fewer term 
     ∀j∈{3, . . . , p n−1 }T j−1   (n)=T   j   (n−1) , i.e. remaining terms unchanged 
     p 1,n−1 =p 2,n−1 =p 1,n , i.e. the two first terms of S (n−1)  have the same number of factors, that is also that of the first term of S (n)    
     ∀j∈{2, . . . , p 1,n−1 }N 1,j   (n−1) =N 2,j   (n−1) , that is to say the two first term can be factorised 
     A and B defined by AN 1,1   (n−1) , BN 2,1   (n−1) , and thus A+B=N 1,1   (n)   
     a bijection            κ        :                   A     ⊕   B     →     A   +   B               ϕ   n                   is                 built                 as        :                     ϕ   n          :             S     (     n   -   1     )           →         S     (   n   )                           x       ↦         {           (     1   ,     κ        (     (     t   ,     x   1       )     )       ,                 if                 t     =     1                 or                                x   2     ,   …              ,       x     p     1   ,     n   -   1                   )                            t   =   2                 (       t   -   1     ,   v     )         otherwise                               With                                                 x   =     (     t   ,   v     )                                                   and                                                 v   =     (       x   1     ,       x   2                   …                   x     p     t   ,     n   -   1               )                                                          
     The term merge κ bijections used by the elementary term merge function can be defined as follows:            κ        :                   A     ⊕   B     →       A   +   B                   MAIN                 TERM                 MERGE                 FUNCTIONS                            
     There are many possible functions that all are computable on any current processor. 
     As an example of κ, the mod-threshold term merge function will be described hereafter: 
     In this function, a merge function is made that is the inverse of the mod-threshod term split function that was already explained. 
     Similarly we have two constants C and T such that:              κ        :             A   ⊕   B         →         A   +   B                           (     t   ,   v     )         ↦         x                 defined                 by                 the                 algorithm                 below                                
     Three constants x M , v M  and t M  are derived from A, B and C according to the following definitions and formulas (the formulas are the same as for the mod-threshold term splitting function): 
     x M  is the greatest x while neither  nor  are empty. 
     t M  is the tag of the set ( or ) not yet empty. 
     v M  is the greatest value of the set not yet empty while both sets are not yet empty.          X   M          =   Δ          max        {     x   ∈       A   +   B     /     (                 l   ·   T     +   c     &lt;   A             if                 c     &lt;   T             and                             l   ·     (     C   -   T     )       +   c   -   T     &lt;   B         otherwise         ,       where                 l     =     x                 div                 C       ,       and                 c     =     x                 mod                 C                  }                 t   M          =   Δ          (         1           if                   (       (       x   M     +   1     )        mod                 C     )       ≥   T             2       otherwise                        v   M          =   Δ          (           max        {       v   /     ∃     x   ≤     x   M           ,     (             l        =   Δ          x                 div                 C               and             c        =   Δ          x                 mod                 C             ⇒     (           c   &lt;   T             and             v   =       l   ·   T     +   c                           }               if                   t   M       =   1               max        {       v   /     ∃     x   ≤     x   M           ,     (             l        =   Δ          x                 div                 C               and             c        =   Δ          x                 mod                 C             ⇒     (           c   ≥   T             and             v   =       l   ·     (     C   -   T     )       +   c   -   T                           }               if                   t   M       =   2                                    
     Then the algorithm that maps (t,v) onto x is the following:          if                 v     ≤       v   M                   or                 t     ≠       t   M                   then           begin           remark                 Neither                 A                 nor                 B                 are                 yet                 empty     ,     then                 discrimination                 is             based                 on                 tag             if                 t     =     1                 then               x   :=         (     v                 div                 T     )     ·   C     +     (     v                 mod                 T     )         ;         else           x   :=     T   +       (     v                 div                   (     C   -   T     )       )     ·   C     +     (     v                 mod                   (     C   -   T     )       )         ;         end       else       begin           remark                 A                 or                 B                 is                 already                 empty     ,     then                 no                 more                 discrimination     ,     
          the                 remainder                 of                 the                 set                 not                 yet                 empty                 is                 mapped                 to                   A   +   B                 x   :=     v   -     v   M     +     x   M         ;                          
     Implementation Matters 
     In fact the method of the invention is not tied to any particular implementation scheme. The method only defines mathematically a permutation, with a definition allowing less tabulation at the expense of more processing. 
     As was already suggested above, the computation of I −1  from its φ k °φ k−1  . . . °φ 1  definition might be done by-a general purpose processor, typically during connection time, in order to prepare a look-up table to be used during interleaving. But as well, this computation might also be done by dedicated hardware circuitry, computing on the fly I −1 (i) from its φ k °φ k−1  . . . °φ 1  definition in order to interleave the (i+1) th  symbol of data when this symbol is to be interleaved. Typically a hardware circuitry could use a pipeline architecture where each step in the pipeline more or less correspond to one φ n , or one compound φ n+p ° . . . °φ n . This kind of architecture is applicable because in order to compute on the fly I −1 (i), what matters is not the total computation time of I −1  (i), but the rate at which they can be computed. This is because the “i” arguments of I −1 (i) come in a predefined order. 
     When a hardware architecture is used, the operations implemented are not necessarily using the mathematical definition of φ n . In order to reduce the circuit size, there can be a mixture of arithmetic units, and of ROM tables. For instance a first x splitting step can be done arithmetically, then the intermediate steps can be done by look up table, and a final x merging step can be done arithmetically again. 
     When a general purpose processor is used, neither are the operations implemented necessarily directly using the mathematical definition of φ n . There might be some optimisations: 
     For instance when N is a power of 2, then splitting  into a product of sets whose respective element numbers are also power of two does not need any division or modulo computation since it can be done by simple bit manipulation such as ORs, ANDs and bit shifts. For instance when mapping  to  by the div-mod factor split function, then the image of x is (y,z), where if x=b7b6b5b4b3b2b1b0 in binary notation, then y=b7b6b5 and z=b4b3b2b1b0. To take it in more practical terms, if x=10110001, then y=101 and z=10001. 
     Also still in the case of a number N of elements that is a power of two, and when there is only one term (or when only one term of size N in the  sum is considered), some factor permutations are implementable by classical processing units instructions such as bit rotation or quartet swap. Let us for instance consider for N=256 the 16×16 rectangular interleaver. The 16×16 rectangular intedeaver comprises in its φ n  compound definition a factor permutation that is swapping the two  factors. In fact, the interleaver permutation can be shown to be not much more than a quartet swap which can be done in one instruction on some processing machines. 
     Non-uniqueness of Definition 
     The inventive method provides means to define an interleaver using less tabulation at the expense of more processing, so that to reduce ROM size requirement. 
     The definition of the interleaver provided by the method might be not unique, since for instance: 
     consecutive splitting steps can sometimes be done in several different ways; for instance a first way to map  onto  is a first divmod splitting function φ 1  mapping  onto  followed by a second div-mod split φ 4 °φ 3 °φ 2  mapping  onto  (φ 2  and φ 4  are the factor permutation function respectively bringing  in first position, and then  in first position again); a second way is a first div-mod splitting function φ′ 1  mapping  onto , followed by a second div-mod split φ′ 2  mapping  onto ; both ways yield the same mapping (φ 4 °φ 3 °φ 2 °φ 1 =φ 2 °φ 1 °), 
     the order of compound of two functions whose action is limited to different factor or terms can be inverted, 
     it is possible to build a function φ n  and its inverse by the inventive method, then you can always insert a compound of several φ n  into the compound defining I −1 , provided that the compound of these several φ n  sums up to the identical function, and has no overall effect, for instance when I −1 =φ k ° . . . °φ 2 °φ 1  is an interleaver over , and N=L·C, then if φ k+1  is defined as the div-mod factor split function that map  to  and φ k+2  as the div-mod factor merge function that maps  to , then I −1  can also be defined as I −1 =φ k+2 °φ k+1 °φ k ° . . . °φ 2 °φ 1  because the compound φ k+2 °φ k+1  has no overall effect. 
     the classification of the φ n  might not be unique, some φ n  can be found under two categories. For instance when all the N 1,j   (n)  are equal then a “factor permutation” φ n  can also be defined as an “affine-mod” φ n  with V=0 and U a permutation matrix. 
     Example of Inventive Method Applied to Known Interleavers 
     The inventive method allows to build interleavers by mixing tabulation (or processing not defined in the invention) and processing (defined in the invention). Here is shown that some well known interleavers can be defined with the inventive method to be implemented in an interleaver device according to the invention. 
     1—The Rectangular Interleaver 
     According to the invention, the classical rectangular interleaver I of depth N=L·C with L lines and C column block is written as: 
     
       
           I   −1 =φ 3 °φ 2 °φ 1   
       
     
     Where: 
     φ 1  is the div-mod elementary factor split function splitting  to  
     φ 2  is the factor permutation function for σ=(2,1), that is to say φ 2  is mapping  on  
     φ 3  is the div-mod elementary factor merge function merging  to  
     The rectangular interleaver is illustrated on FIG.  6 . 
     2—The Diagonal Interleaver 
     The usual diagonal interleaver I depth N=L·C, with L lines and C column block, where lines are written first and then diagonal are read, when j th  diagonal begins at the first element of j th  line is written as: 
     
       
           I   −1 =φ 3 °φ 2 °φ 1   
       
     
     Where: 
     φ 1  is the div-mod elementary factor split function splitting  to  
     φ 2  is the affine-mod function with V=0 and        U   =     [         1       1           0       1         ]                            
     φ 3  is the div-mod elementary factor merge function merging  to  
     3—The Truncated Rectangular Interleaver 
     Truncated rectangular interleavers are used in MIL interleavers which are defined in ETSI SMG2 UMTS-L1 EG Tdoc 98/273 “Multi-stage interleaving (MIL) method for Turbo codes” by “NTT DoCoMo”. In a truncated rectangular interleaver the N input data is written along lines in a block of L′ lines and C′ columns, with C′ which is not a divider of N (and L′ great enough for L′·C′≧N). Then the data is read out along columns. 
     The truncated rectangular interleaver is illustrated on FIG. 7 with N=20 and C′=6. 
     The truncated rectangular interleaver is defined by the method of the invention as the  sum of two rectangular interleavers. 
     
       
           I   −1 =φ 8 °(φ 7 °φ 6 °φ 5 )°(φ 4 °φ 3 °φ 2 )°φ 1   
       
     
     Where: 
     φ 1  is the mod-threshold elementary term split function, where C=C′ and T=N mod C′. 
     φ 1   to  with 
     
       
           N   1 =( N  div  C ′+1)·( N  mod  C ′), and 
       
     
     
       
           N   2 =( N  div  C ′)·( C ′−( N  mod  C ′)) 
       
     
     (φ 4 °φ 3 °′φ 2 ) is the first rectangular interleaver that is applied to  with parameters: 
     
       
           L =( N  div  C ′+1), and 
       
     
     
       
           C =( N  mod  C ′) 
       
     
     (φ 7 °φ 6 °φ 5 )is the second rectangular interleaver that is applied to  with parameters: 
     
       
           L =( N  div  C ′), and 
       
     
     
       
           C=C ′−( N  mod  C ′) 
       
     
     φ 8  is the term merge function with C=N 1 +N 2  and T=N 1 . 
     4—The Mil Interleaver 
     The MIL interleavers defined in ETSI SMG2 UMTS-L1 EG T doc 98/273 “Multi-stage interleaving (MIL) method for Turbo codes” by “NTT Do-CoMo” can also be constructed by the method of the invention. The MIL interleaver is defined recursively, and the method of the invention is by essence recursive. 
     A MIL interleaver of depth N=L·C is defined as the succession of the following steps: 
     1) First write the input data along the lines of the rectangular block of L lines and C columns; 
     2) Then interleave each line by either a rectangular interleaver, or a trunctated rectangular interdaver, or a MIL interleaver; and 
     3) Finally read the block by columns. 
     The first step consists of (φ 2 °φ 1 ), where φ 1  is the div-mod factor split function applied to  and mapping it to  and φ 2  is the distribution function that maps      N                        
     where each term consists of a line of the block. 
     The second steps consists in applying a rectangular, a truncated rectangular or a MIL interleaver to each term. As already seen, rectangular and truncated rectangular intedeaver can be generated by the method of the invention, then this second step is also within the invention. 
     The third step consisting of reading the block by column can be simply written as (φ k °φ k−1 °φ k−2 ), where φ k−2  is the factorisation function mapping                C   ⊕   …   ⊕   C            L                 times                     to                 L   ×   C     ,                          
     φ k−1  a factor permutation mapping  to , and φ k  the div-mod factor merge. 
     In conclusion MIL interleavers are a subset of the interleavers that can be generated by the inventive method. 
     5—Other Interleavers 
     The inventive method is open to embed other interleavers into the inventive interleavers by means of the elementary interleaving function. After decomposing S (0) = into a sum of products of sets of the  form, an interleaver not defined by this document can be applied to only one of this factor set: this is what is called elementary interleaving in this document. 
     In the definition of many existing intedeaver a similar method is also used, for instance in ETSI SMG2 UMTS-L1 EG Tdoc 98/337 “A General Turbo Interleaver Design Technique with Near Optimal Performance” by “Hughes Network Systems”, we can read that such a process is used: 
     writing the symbol in a rectangular block along the rows: this corresponds to a div-mod factor split of  to  
     then operating on each row separately: this corresponds to a distribution of  product in a sum of L terms  . . .  each term being a row, 
     shuffling each row by some rule derived from Galois field arithmetic: this corresponds to an elementary interleaving applied to the term of which the row is consisting. 
     permutating the rows: this can be expressed either as a term permutation, or as factorising to  again, and making an elementary interleaving bearing on the  dimension. 
     reading by column: this is also interpreted in the inventive method, we first swap the two factors in  by a factor permutation, then make a div-mod factor merge. 
     The invention brings some methodology allowing to define an interleaver in a unified formal language. This would ease specification of interleavers by defining the compound or sequence of the φ n . Such a specification would be without ambiguity, and even possibly in a language that is directly machine processable. Such a sequence can be coded in a dedicated binary format, for instance a TLV format, where T (tag) gives the type of φ n  (factor split, term split, affine-mod, etc.) and the LV (length+value) gives the characteristics of φ n , for instance if φ n  is affine-mod, the matrix U and the vector V. Such a coded format can be used to defined a great variety of interleavers in a device at a very low ROM memory cost. Also the same format can be used on an interface to negotiate which interleaver is to be used. 
     The term split is also of a great interest. Many arithmetic interleavers (e.g. GF interleaver as defined in ETSI SMG2 UMTS-L1 EG Tdoc 98/337 “A General Turbo Interleaver Design Technique with Near Optimal Performance” by “Hughes Network Systems”, for N=2 m ) are primarily defined for some N that has good properties. When an interleaver with an N that has not such good properties needs to be built, then an arithmetic interleaver with N′&gt;N and N′ having the good properties is built, and then punctured down to N. Puncturing an interleaver is not done at a very high processing power when it consists in modifying a RAM table. However these forces an implementation where first the interleaver is prepared in a RAM table, and then this RAM table is used. Implementation where the interleaver function is computed real time by an ASICs cannot be realistically considered with puncturing. Thanks to the term splitting function instead of searching for N′ with good arithmetic properties and N′&gt;N, one can find N′ with good arithmetic properties such that N′&lt;N, and then apply the arithmetic interleaver to a term of size N′, thus avoiding any puncturing. 
     Puncturing of an interleaver is shown on FIG.  8 . An interleaver I 8  of depth 8 is punctured down to a depth of 5 to form an interleaver I 5 . In the upper part of the figure a table where the values of I 8   −1  are shown. The table entry number (above the table) is the value of i, and the entry value (inside the table) is the value of I 8   −1 (i). In other words we have I 8   −1 (0)=3, I 8   −1 (1)=0, etc. Then all the entries such that I 8   −1 (i)≧5 are to be punctured. These entries are marked on the figure by a triangle. Puncturing consists in moving some part of the table, for instance the entry in position 4 is moved to position 2 so that I 5 (2)=I 8 (4)=1. 
     After puncturing, the 5 first entries of the table contain only numbers ranging from 0 to 4.