Patent Document

CROSS-REFERENCE TO RELATED PATENT APPLICATIONS  
       [0001]     This application is an application claiming the benefit under 35 USC 119(e) of U.S. Application No. 60/599,283, filed Aug. 5, 2004, incorporated herein by reference in its entirety. 
     
    
     FIELD OF THE INVENTION  
       [0002]     The present invention relates generally to correction codes in communication systems. More particularly, the present invention relates to the use of correction codes for reliably conveying information through channels having random events.  
       BACKGROUND OF THE INVENTION  
       [0003]     Modern communication systems use Forward Error Correction (FEC) codes in an attempt to convey information more reliably through channels with random events. One such FEC error control system uses low density parity check (LDPC) codes. LDPC codes can have error correcting capabilities that rival the performance of “Turbo-Codes” and can be applicable over a wide range of statistical channels. In fact, some random irregular LDPC constructions based upon edge ensemble designs have error correcting capabilities measured in Bit Error Rate (BER) that are within 0.05 dB of the rate-distorted Shannon limit. Unfortunately, these LPDC code constructions often require long codeword constructions (on the order of 10 6  to 10 7  bits) in order to achieve these error rates. Despite good BER performance, these random code constructions often have poor Block Error Rate (BLER) performances. Therefore, these random constructions typically do not lend themselves well to packet-based communication systems.  
         [0004]     Another disadvantage of random constructions based on edge distribution ensembles is that, for each codeword length, a separate random construction is needed. Thus, communication systems employing variable block sizes (e.g. TCP/IP systems) require multiple code definitions. Such multiple code definitions can consume a significant amount of non-volatile memory for large combinations of codeword lengths and code rates.  
         [0005]     As an alternative to random LDPC constructions, structured LDPC constructions typically rely on a general algorithmic approach to constructing LDPC matrices which often requires much less non-volatile memory than random constructions. One such structured approach is based upon array codes. This approach can exhibit improved error performance (both BER and BLER performance) and a relatively low error floor for relatively high code rates (higher than 0.85). However, for code rates below 0.85, these code constructions have relatively poor performance with respect to irregular random constructions designed for lower code rates. One reason for this poor performance can be that their constructions are typically based on code ensembles that have poor asymptotic performances despite being an irregular construction.  
         [0006]     One challenge therefore is to design irregular structured LDPC codes that have good overall error performance for a wide range of code rates with attractive storage requirements. Such resulting LDPC codes would provide a better performing communication system with lower cost terminals. These factors can make such FEC attractive for applications over a wide range of products, including but not limited to, wireless LAN systems, next generation cellular systems, and ultra wide band systems.  
       SUMMARY OF THE INVENTION  
       [0007]     Embodiments of the present invention provides for an irregularly structured LDPC code ensemble that has strong overall error performance and attractive storage requirements for a large set of codeword lengths. Embodiments of the invention offer communication systems with better performance and lower terminal costs due to the reduction in mandatory non-volatile memory over conventional systems.  
         [0008]     In contrast to conventional approaches, embodiments of the invention provide a structured approach to construction, offering reduced storage requirements and a simple construction. When used with seed matrices with good asymptotic performances and good girth properties, the irregularly structured LDPC codes used in embodiments of the present invention offer an improved overall level of error performance. Embodiments of the invention also offer a parity-check matrix that is lower in density than conventional array codes because there are fewer non-zero sub-matrices (i.e. there are more sub-matrices consisting of the all zeros matrix).  
         [0009]     These and other objects, advantages and features of the invention, together with the organization and manner of operation thereof, will become apparent from the following detailed description when taken in conjunction with the accompanying drawings, wherein like elements have like numerals throughout the several drawings described below. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0010]      FIG. 1  is an overview diagram of a system within which embodiments of the invention may be implemented;  
         [0011]      FIG. 2  is a perspective view of a mobile telephone that can be used in the implementation of one embodiment the present invention;  
         [0012]      FIG. 3  is a schematic representation of the telephone circuitry of the mobile telephone of  FIG. 2 ;  
         [0013]      FIG. 4  is a flow chart showing the implementation of one embodiment of the present invention;  
         [0014]      FIG. 5  is an example of a code rate ½ irregular parity-check matrix according to one embodiment of the present invention;  
         [0015]      FIG. 6  is an example of a code rate ⅔ irregular parity-check matrix according to one embodiment of the present invention; and  
         [0016]      FIG. 7  is an example of a code rate ¾ irregular parity-check matrix according to one embodiment of the present invention.  
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0017]     Various exemplary embodiments of the invention are described below with reference to the drawing figures. One embodiment of the invention can be described in the general context of method steps, which may be implemented in one embodiment by a program product including computer-executable instructions, such as program code, executed by computers in networked environments. Embodiments of the invention may be implemented in either hardware or software, and can be placed both within a transmitter and/or a receiver.  
         [0018]      FIG. 1  shows a system  10  illustrating one embodiment of the invention, comprising multiple communication devices that can communicate through a network. The system  10  may comprise any combination of wired or wireless networks including, but not limited to, a mobile telephone network, a wireless Local Area Network (LAN), a Bluetooth personal area network, an Ethernet LAN, a token ring LAN, a wide area network, the Internet, etc. The system  10  may include both wired and wireless communication devices.  
         [0019]     For exemplification, the system  10  shown in  FIG. 1  can include a mobile telephone network  11  and the Internet  28 . Connectivity to the Internet  28  may include, but is not limited to, long range wireless connections, short range wireless connections, and various wired connections including, but not limited to, telephone lines, cable lines, power lines, and the like.  
         [0020]     Exemplary communication devices of the system  10  may include, but are not limited to, a mobile telephone  12 , a combination PDA and mobile telephone  14 , a PDA  16 , an integrated messaging device (IND)  18 , a desktop computer  20 , and a notebook computer  22 . The communication devices may be stationary or mobile as when carried by an individual who is moving. The communication devices may also be located in a mode of transportation including, but not limited to, an automobile, a truck, a taxi, a bus, a boat, an airplane, a bicycle, a motorcycle, etc. Some or all of the communication devices may send and receive calls and messages and communicate with service providers through a wireless connection  25  to a base station  24 . The base station  24  may be connected to a network server  26  that allows communication between the mobile telephone network  11  and the Internet  28 . The system  10  may include additional communication devices and communication devices of different types. A communication device may communicate using various media including, but not limited to, radio, infrared, laser, cable connection, and the like. One such portable electronic device incorporating a wide variety of features is shown in  FIG. 4 . This particular embodiment may serves as both a video gaming device and a portable telephone.  
         [0021]     The communication devices may communicate using various transmission technologies including, but not limited to, Code Division Multiple Access (CDMA), Global System for Mobile Communications (GSM), Universal Mobile Telecommunications System (UMTS), Time Division Multiple Access (TDMA), Frequency Division Multiple Access (FDMA), Transmission Control Protocol/Internet Protocol (TCP/IP), Short Messaging Service (SMS), Multimedia Messaging Service (MMS), e-mail, Instant Messaging Service (IMS), Bluetooth, IEEE 802.11, etc.  
         [0022]      FIGS. 2 and 3  show one representative mobile telephone  12  within which one embodiment of the present invention may be implemented. It should be understood, however, that the present invention is not intended to be limited to one particular type of mobile telephone  12  or other electronic device. The mobile telephone  12  of  FIGS. 2 and 3  comprises a housing  30 , a display  32  in the form of a liquid crystal display, a keypad  34 , a microphone  36 , an ear-piece  38 , a battery  40 , an infrared port  42 , an antenna  44 , a smart card  46  in the form of a universal integrated circuit card (UICC) according to one embodiment of the invention, a card reader  48 , radio interface circuitry  52 , codec circuitry  54 , a controller  56  and a memory  58 .  
         [0023]     Generally, program modules can include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Computer-executable instructions, associated data structures, and program modules represent examples of program code for executing steps of the methods disclosed herein. The particular sequence of such executable instructions or associated data structures represents examples of corresponding acts for implementing the functions described in such steps.  
         [0024]     Software and web implementations of the present invention could be accomplished with standard programming techniques with rule-based logic and other logic to accomplish the various database searching steps, correlation steps, comparison steps and decision steps. It should also be noted that the words “component” and “module” as used herein, and in the claims, are intended to encompass implementations using one or more lines of software code, and/or hardware implementations, and/or equipment for receiving manual inputs.  
         [0025]     By taking into account the density evolution of messages passed in belief propagation decoding, random constructions of irregular LDPC codes can be developed that approach Shannon limits for an assortment of channels (e.g. Additive White Gaussian Noise (AWGN), Binary Erasure Channel (BEC), Binary Symmetric Channel (BSC)). These are typically described as ensembles with variable and check edge polynomials  
         λ   ⁡     (   x   )       =       ∑     i   =   2       d   l       ⁢       λ   i     ⁢     x     i   -   1               
 
 and  
           ρ   ⁡     (   x   )       =       ∑     j   =   2       d   r       ⁢       ρ   j     ⁢     x     j   -   1             ,       
 
 respectively, where λ i  and ρ j  are the fraction of total edges connected to variable and check nodes of degree i=2,3, . . . , d, and j=2,3, . . . , d, respectively. These random constructions sometimes require the relatively long codeword lengths to approach the capacity limit and do not always provide the strong BLER performance required by packet-based communication systems. In actual communication terminals, these random constructions can require storage of the entire parity-check matrix, and for systems employing variable packet-length, the storage of multiple random constructions is both necessary and costly. 
 
         [0026]     Alternatively, structured approaches to LDPC code designs that allow for reduced storage requirements and simple code description may be used. One such example is the LDPC code construction based upon array constructions. For code rates 0.85 and above, these code constructions can have acceptable performance with good error floors and BLERs. However, with respect to random constructions, these constructions sometimes suffer at lower code rates because they have edge distributions that result in relatively poor asymptotic performance and thus poor performance in general.  
         [0027]     It is desirable thus, to provide irregularly structured LDPC codes that have good overall error performance for a wide range of code rates with attractive storage requirements that make communication terminals cost effective. The result of such LDPC codes can do a better performing communication system with lower cost terminals. These factors can make such a FEC attractive for applications over a wide range of products including but not limited to wireless LAN, next generation cellular systems, and ultra wide band systems.  
         [0028]     As discussed herein, an irregular “seed” parity-check matrix can be used as the “seed” for irregular structured LDPC code some embodiments according to the present invention. One embodiment invention involves the construction of an irregular “seed” low-density parity check-matrix H SEED  of dimension ((N SEED −K SEED )×N SEED ) derived from an edge distribution, λ SEED  (x) and ρ SEED  (x), with good asymptotic performance and good girth properties. In one embodiment, good asymptotic performance may be characterized by a good threshold value using belief propagation decoding and good girth may be characterized by having very few if no variable nodes with a girth of 4. This can be accomplished manually or via a software program once given the code ensemble and/or node degrees.  
         [0029]     Although there are no limits on the maximum values of K SEED  and N SEED , which represent the number of information bits and the resulting codeword length, respectively in one embodiment, for the code defined by H SEED , these values can be relatively small in comparison to the target message-word and codeword length. This can allow for more potential integer multiples of N SEED  within the target range of codeword lengths, reduced storage requirements, and simplified code descriptions. In one embodiment of the invention, the smallest possible value for H SEED  can be used with edge distributions defined by λ SEED  (x) and ρ SEED  (x), while still maintaining good girth properties.  
         [0030]     One function of the seed matrix can be to identify the location and type of sub-matrices in the expanded LDPC parity-check matrix H constructed from H SEED  and a given set of permutation matrices. The permutation matrices in H SEED  can determine the location of sub-matrices in the expanded matrix H that contain a permutation matrix of dimension (N SPREAD ×N SPREAD ) from the given set. One selection within the given set of permutation matrices is defined below. As an example only, the given set of permutation matrices used herein can be finite and consist of the set 
 
{ P   SPREAD   ∞   , P   SPREAD   0   , P   SPREAD   1   , P   SPREAD   2   , . . . , P   SPREAD   p-1 }
 
         [0031]     where p is a positive integer (a prime number in a preferred embodiment of the invention), P SPREAD   0 =I is the identity matrix, P SPREAD   1  is a full-rank permutation matrix, P SPREAD   2 =P SPREAD   1 P Spread   1 , etc. up to P SPREAD   p-1 . One example embodiment of P SPREAD   1  is a single circular shift mutation matrix  
         P   SPREAD   1     =         [         0       1       0       0       0           0       0       1       0       0           0       0       0       1       0           0       0       0       0       1           1       0       0       0       0         ]     ⁢           ⁢   for   ⁢           ⁢     N   SPREAD       =   5         
 
         [0032]     Another example embodiment of P SPREAD   1  is an alternate single circular shift permutation matrix  
         P   SPREAD   1     =         [         0       0       0       0       1           1       0       0       0       0           0       1       0       0       0           0       0       1       0       0           0       0       0       1       0         ]     ⁢           ⁢   for   ⁢           ⁢     N   SPREAD       =   5.         
 
         [0033]     For notational sake, P SPREAD   ∞  denotes the all zeros matrix 0 of dimension (N SPREAD ×N SPREAD ) (i.e. P SPREAD   ∞ =0 where every element is a zero), and the zeros in H SEED  indicate the location of the sub-matrix P SPREAD   ∞ =0 in the expanded matrix H. Thus, the expanded LDPC matrix H can be of dimension (N SPREAD (N SEED −K SEED )×N SPREAD N SEED ) with sub-matrices consisting of permutation matrices of dimension (N SPREAD ×N SPREAD ) raised to an exponential power from the set of {0,1, . . . , p−1, ∞}.  
         [0034]     Furthermore, the expanded LDPC code can have the same edge distribution as H SEED  and hence can achieve the desired asymptotic performance described by λ SEED  (x) and ρ SEED  (x), provided both H SEED  and the expanded matrix H have satisfactory girth properties.  
         [0035]     The following description concerns one embodiment of the invention that constructs a structured array exponent matrix that may be described as  
           E   ARRAY     =     [           E     1   ,   1             E     1   ,   2           …         E     1   ,   p                 E     2   ,   1             E     2   ,   2           …         E     2   ,   p               ⋮       ⋮       ⋰       ⋮             E     p   ,   1             E     p   ,   2           …         E     p   ,   p             ]       ,       where   ⁢           ⁢     E     i   ,   j         =       (     i   -   1     )     ⁢     (     j   -   1     )     ⁢           ⁢   mod   ⁢           ⁢   p           
 
         [0036]     using modulo arithmetic (but not limited to) of a number p. In one embodiment of the invention, p can be a prime number, but this is not necessary for the principles of the present invention. p can be at least the column dimension of the irregular “seed” parity check matrix and the column dimension of the spreading permutation matrix. In one embodiment, N SEED ≦p and N SPREAD ≦p. However, other values are also possible.  
         [0037]     Other embodiments of the present invention can use transformed versions of E ARRAY . In particular, one such transformation involves the shifting of rows to construct an upper triangular matrix while replacing vacated element locations with ∞, i.e.  
         E   SHIFT     =       [           E     1   ,   1             E     1   ,   2             E     1   ,   3           …         E     1   ,   p               ∞         E     2   ,   1             E     2   ,   2           …         E     2   ,     p   -   1                 ∞       ∞         E     3   ,   1           …         E     3   ,     p   -   2                 ⋮       ⋮       ⋮       ⋰       ⋮           ∞       ∞       ∞       …         E     p   ,   1             ]     .         
 
         [0038]     Another embodiment of the present invention transforms E ARRAY  by the truncation of columns and/or rows to select a sub-matrix of E ARRAY  for implementation with a specified H SEED . Still another embodiment of the invention uses the combination of both shifting and truncation. For example, given N SEED +1≦p and N SPREAD ≦p (with p being a prime number in a particular embodiment of the invention)  
         E   TRUNCATE1     =     [           E     1   ,   2             E     1   ,   3             E     1   ,   4           …         E     1   ,     (       N   SEED     -     K   SEED       )             …         E     1   ,     (       N   SEED     +   1     )                   E     2   ,   1             E     2   ,   2             E     2   ,   3           …         E     2   ,     (       N   SEED     -     K   SEED     -   1     )             …         E     2   ,     N   SEED                 ∞         E     3   ,   1             E     3   ,   2           …         E     3   ,     (       N   SEED     -     K   SEED     -   2     )             …         E     3   ,     (       N   SEED     -   1     )                 ⋮       ⋮       ⋰       ⋰       ⋮       ⋰       ⋮           ∞       ∞       ∞       …         E       (       N   SEED     -     K   SEED       )     ,   1           …         E       (       N   SEED     -     K   SEED       )     ,     (       K   SEED     +   2     )               ]         
 
         [0039]     For N SEED +2≦p and N SPREAD ≦p (with p being a prime number in a particular embodiment of the invention)  
         E   TRUNCATE2     =       [           E     2   ,   2             E     2   ,   3             E     2   ,   4           …         E     2   ,     (       N   SEED     -     K   SEED       )             …         E     2   ,     (       N   SEED     +   1     )                   E     3   ,   1             E     3   ,   2             E     3   ,   3           …         E     3   ,     (       N   SEED     -     K   SEED     -   1     )             …         E     3   ,     N   SEED                 ∞         E     4   ,   1             E     4   ,   2           …         E     4   ,     (       N   SEED     -     K   SEED     -   2     )             …         E     4   ,     (       N   SEED     -   1     )                 ⋮       ⋮       ⋰       ⋰       ⋮       ⋰       ⋮           ∞       ∞       ∞       …         E       (       N   SEED     -     K   SEED     +   1     )     ,   1           …         E       (       N   SEED     -     K   SEED     +   1     )     ,     (       K   SEED     +   2     )               ]     .         
 
         [0040]     Many shift and truncate embodiments can be used with the present invention, as well as column and row permutation transformations performed either prior to or after other individual transformations in a nested fashion. More generally, the transformation of the E ARRAY  matrix can be described using the functional notation T(E ARRAY ) that represents a transformed exponent matrix of dimension ((N SEED −K SEED )×N SEED ). Yet another embodiment of this family of transformations may include an identity transformation. For example, in another embodiment of the invention, T(E ARRAY )=E ARRAY .  
         [0041]     In one embodiment of the present invention H SEED  and T(E ARRAY ) can be used to construct the final exponent matrix in order to expand the seed matrix into H. The final exponent matrix may be defined as  
         F   FINAL     =     [           F     1   ,   1             F     1   ,   2           …         F     1   ,     N   SEED                   F     2   ,   1             F     2   ,   2           …         F     2   ,     N   SEED                 ⋮       ⋮       ⋰       ⋮             F       (       N   SEED     -     K   SEED       )     ,   1             F       (       N   SEED     -     K   SEED       )     ,   2           …         F       (       N   SEED     -     K   SEED       )     ,     N   SEED               ]         
 
         [0042]     of dimension ((N SEED −K SEED )×N SEED ) by replacing each one in H SEED  with the corresponding matrix element (i.e. the same row and column) in the transformed structured array exponent matrix T(E ARRAY ) and each zero in H SEED  with ∞. Thus, the elements of F FINAL  can belong to the set {0,1, . . . , p−1, ∞} if modulo arithmetic is used in the construction of E ARRAY .  
         [0043]     The following is a discussion of one embodiment of the expansion of H SEED  using F FINAL  to construct a final LDPC parity-check matrix H that describes the LDPC code. The matrix H SEED  of dimension ((N SEED −K SEED )×N SEED ) can be spread or expanded using the elements of the permutation matrix set 
 
{ P   SPREAD   ∞ , P SPREAD   0 , P SPREAD   1 , P SPREAD   2 , . . . , P SPREAD   p-1 }
 
         [0044]     with elements of dimension (N SPREAD ×N SPREAD ), where P SPREAD   ∞ =0 is the all zeros matrix, P SPREAD   0 =I is the identity matrix, P SPREAD   1  is a permutation matrix, P SREAD   2 =P SPREAD   1 P SPREAD   1 , P SPREAD   3 =P SPREAD   1 P SPREAD   1 P SPREAD   1 , etc. (but not limited to) to construct  
       H   =     [           P   SPREAD     F     1   ,   1               P   SPREAD     F     1   ,   2             …         P   SPREAD     F     1   ,     N   SEED                     P   SPREAD     F     2   ,   1               P   SPREAD     F     2   ,   2             …         P   SPREAD     F     2   ,     N   SEED                   ⋮       ⋮       ⋰       ⋮             P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,   1               P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,   2             …         P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,     N   SEED                 ]         
 
         [0045]     of dimension (N SPREAD (N SEED −K SEED )×N SPREAD N SEED ). Thus, this embodiment of the present invention can be used to describe an expanded LDPC code with sub-matrices of dimension (N SPREAD ×N SPREAD ) in the (i, j) th  sub-matrix location consisting of the permutation matrix P SPREAD  raised to the F i,j  power (i.e. P SPREAD   F     i,j   )  
         [0046]     The following is one particular example of the implementation of one embodiment of the present invention. In this example,  
           H   SEED     =     [         1       0       0       1       0       0           1       1       0       1       1       0           0       1       1       0       0       1           0       0       1       0       1       1         ]       ,       thus   ⁢           ⁢     N   SEED       =   6     ,       
 
         [0047]     while  
           P   SPREAD   1     =     [         0       0       1           1       0       0           0       1       0         ]       ,       thus   ⁢           ⁢     N   SPREAD       =   3     ,       
 
         [0048]     Therefore, p=11 is the smallest prime number that satisfies the example conditions N SEED +2 ≦p and N SPREAD ≦p. The interim and final exponent matrices as defined above can be:  
               E   TRUNCATE2     =       [         1       2       3       4       5       6           0       2       4       6       8       10           ∞       0       3       6       9       1           ∞       ∞       0       4       8       1         ]     ⁢           ⁢   and                   F   =     [         1       ∞       ∞       4       ∞       ∞           0       2       ∞       6       8       ∞           ∞       0       3       ∞       ∞       1           ∞       ∞       0       ∞       8       1         ]       ,             
 
         [0049]     and the corresponding expanded LDPC matrix can be:  
       H   =       [         0       0       1       0       0       0       0       0       0       0       0       1       0       0       0       0       0       0           1       0       0       0       0       0       0       0       0       1       0       0       0       0       0       0       0       0           0       1       0       0       0       0       0       0       0       0       1       0       0       0       0       0       0       0           1       0       0       0       1       0       0       0       0       1       0       0       0       1       0       0       0       0           0       1       0       0       0       1       0       0       0       0       1       0       0       0       1       0       0       0           0       0       1       1       0       0       0       0       0       0       0       1       1       0       0       0       0       0           0       0       0       1       0       0       1       0       0       0       0       0       0       0       0       0       0       1           0       0       0       0       1       0       0       1       0       0       0       0       0       0       0       1       0       0           0       0       0       0       0       1       0       0       1       0       0       0       0       0       0       0       1       0           0       0       0       0       0       0       1       0       0       0       0       0       0       1       0       0       0       1           0       0       0       0       0       0       0       1       0       0       0       0       0       0       1       1       0       0           0       0       0       0       0       0       0       0       1       0       0       0       1       0       0       0       1       0         ]     .         
 
         [0050]     One embodiment of a method for constructing irregularly structured LDPC codes according to the present invention is depicted in  FIG. 4 . At step  100 , an irregular “seed” parity check matrix H SEED  of dimension ((N SEED −K SEED )×N SEED ) can be constructed, being derived from an edge ensemble, λ SEED (x) and ρ SEED (x), with good asymptotic performance. In one embodiment, good asymptotic performance can be characterized by good threshold value using belief propagation decoding and good girth properties such as by having very few if no variable nodes with girth of 4. At step  110 , a structured array exponent matrix can be constructed, as shown below:  
         E   ARRAY     =         [           E     1   ,   1             E     1   ,   2           ⋯         E     1   ,   p                 E     2   ,   1             E     2   ,   2           ⋯         E     2   ,   p               ⋮       ⋮       ⋰       ⋮             E     p   ,   1             E     p   ,   2           ⋯         E     p   ,   p             ]     ⁢           ⁢   where   ⁢           ⁢     E     i   ,   j         =       (     i   -   1     )     ⁢     (     j   -   1     )     ⁢           ⁢   mod   ⁢           ⁢   p           
 
         [0051]     This matrix can be constructed using modulo arithmetic of a number p that can be at least the column dimension of the irregular “seed” parity check matrix and the column dimension of the spreading permutation matrix. In other words, N SEED ≦p and N SPREAD ≦p.  
         [0052]     At step  120 , the structured array exponent matrix can be transformed using a transform T(E ARRAY ) that may perform shifts, truncations, permutations, etc. operations to construct an exponent matrix of dimension ((N SEED −K SEED )×N SEED ) from E ARRAY . At step  130 , a final exponential matrix can be constructed,  
         F   FINAL     =     [           F     1   ,   1             F     1   ,   2           ⋯         F     1   ,     N   SEED                   F     2   ,   1             F     2   ,   2           ⋯         F     2   ,     N   SEED                 ⋮       ⋮       ⋰       ⋮             F       (       N   SEED     -     K   SEED       )     ,   1             F       (       N   SEED     -     K   SEED       )     ,   2           ⋯         F       (       N   SEED     -     K   SEED       )     ,     N   SEED               ]         
 
         [0053]     of dimension ((N SEED −K SEED )×N SEED ) by replacing each one in H SEED  with the corresponding element in the transformed structured array exponent matrix T(E ARRAY ) and each zero in H SEED  with ∞. Thus, the elements of F FINAL  belong to the set {0,1 , . . . , p−1, ∞}.  
         [0054]     At step  140 , the expanded parity check matrix can be constructed,  
       H   =     [           P   SPREAD     F     1   ,   1               P   SPREAD     F     1   ,   2             ⋯         P   SPREAD     F     1   ,     N   SEED                     P   SPREAD     F     2   ,   1               P   SPREAD     F     2   ,   2             ⋯         P   SPREAD     F     2   ,     N   SEED                   ⋮       ⋮       ⋰       ⋮             P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,   1               P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,   2             ⋯         P   SPREAD     F       (       N   SEED     -     K   SEED       )     ,     N   SEED                 ]         
 
         [0055]     of dimension (N SPREAD (N SEED −K SEED )×N SPREAD N SEED ) that describes the expanded LDPC code with sub-matrices of dimension (N SPREAD ×N SPREAD ) in the (i, j) th  sub-matrix location consisting of the permutation matrix P SPREAD  raised to the F i,j  power, i.e. P SPREAD   F     i,j   , where F i,j  is the matrix element in the (i,j) th  location of F FINAL .  
         [0056]      FIG. 5  is an example of one embodiment of a rate ½ irregular parity-check matrix.  FIG. 6  is an example of one embodiment of a rate ⅔ irregular parity-check matrix.  FIG. 7  is an example of one embodiment of a rate ¾ irregular parity-check matrix.  
         [0057]     The foregoing description of embodiments of the present invention have been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the present invention to the precise form disclosed, and modifications and variations are possible in light of the above teachings or may be acquired from practice of the present invention. The embodiments were chosen and described in order to explain the principles of the present invention and its practical application to enable one skilled in the art to utilize the present invention in various embodiments and with various modifications as are suited to the particular use contemplated.

Technology Category: 5