Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836
PEG based LDPC Codes Construction Methods Sandip J. Sukhdeve*, Rahul Kamdi**, Dr. R. N. Awale***, D. P. Rathod**** *(Student, M.Tech. Electronics, Veermata Jijabai Technological Institute, Mumbai) **(Student, M.Tech. Electronics and Telecommunications, Veermata Jijabai Technological Institute, Mumbai) *** (Professor, Department of Electrical Engineering, Veermata Jijabai Technological Institute, Mumbai) ****(Asst. Professor, Department of Electrical Engineering, Veermata Jijabai Technological Institute, Mumbai)
ABSTRACT The PEG algorithm is a well-known procedure to construct regular and irregular lowdensity parity-check codes. In this paper, a review of the construction methods including the PEG algorithm and some modified algorithms is made to analyse their performance. A novel approach to constructing Tanner graphs using progressive edge growth (PEG) is discussed called Error Minimization progressive edge growth (EMPEG). It yields LDPC codes providing minimized block error probability in Binary Erasure Channels (BEC). The constructed codes exhibit superior performance over codes generated by previously known algorithms, both for BEC and AWGN channels.
in a fixed number, wc, of parity checks and each parity-check equation contains a fixed number, wr, of code bits. In order to do this, the parity check matrix should usually be very large. An LDPC code is called regular if wc is constant for every column and wr = wc · (n/m) is also constant for every row. The example matrix from equation is regular with wc = 2 and wr = 4. It’s also possible to see the regularity of this code while looking at the graphical representation. There is the same number of incoming edges for every v-node and also for all the c-nodes. If H is low density but the numbers of 1’s in each row or column aren’t constant the code is called an irregular LDPC code.
Keywords - Girth, low density parity check (LDPC) codes, progressive edge growth (PEG), approximate cycle extrinsic message degree (ACE).
I. INTRODUCTION LDPC codes are the block codes with parity-check matrices that contain only a very small number of non-zero entries. LDPC codes match Turbo codes in decoding performance. However, they have several advantages over Turbo codes including parallelism in decoding and simple computation operations. LDPC decoding computations are divided into two sets of nodes, check and variable nodes. Nodes on each side do computations independently of each other. A node is only connected to nodes on the other side. This allows computations in each side to be done in parallel. Basically there are two different possibilities to represent LDPC codes. Like all linear block codes they can be described via matrices. The second possibility is a graphical representation. The matrix defined in the figure is a parity check matrix with dimension n×m for a (8, 4) code. We can now define two numbers describing these matrix. wr for the number of 1’s in each row and wc for the columns. For a matrix to be called low-density, the two conditions wc << n and wr << m must be satisfied. An LDPC code parity-check matrix is called (wc, wr)-regular if each code bit is contained
Fig.1.1: Matrix and Graphical Representation of Parity Check matrix. Tanner introduced an effective graphical representation for LDPC codes. Not only these graphs provide a complete representation of the code, they also help to describe the decoding algorithm. Tanner graphs are bipartite graphs. That means that the nodes of the graph are separated into two distinctive sets and edges are only connecting nodes of two different types. The two types of nodes in a Tanner graph are called variable nodes (vnodes) and check nodes (c-nodes). Figure 1.1 is an example for such a Tanner graph and represents the same code as in the matrix. The creation of such a graph is rather straight forward. It consists of m
1831 | P a g e
Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836 check nodes (the number of parity bits) and n variable nodes (the number of bits in a code word). Check node fi is connected to variable node cj if the element hij of H is a 1. The marked path in the figure, c2 → f1 → c5 → f2 → c2 is an example for a short cycle. Those should usually be avoided since they are bad for decoding performance. A cycle in a Tanner graph is a sequence of connected vertices which start and end at the same vertex in the graph, and which contain other vertices no more than once. The length of a cycle is the number of edges it contains, and the girth of a graph is the size of its smallest cycle. Several different algorithms exist to construct suitable LDPC codes. Gallager himself introduced one [1]. Furthermore MacKay proposed one to semi-randomly generate sparse parity check matrices [2]. Despite many advantages, good LDPC code construction methods and efficient hardware (encoder and decoder) implementations are still a challenge. The challenge is to find ways of constructing good performing LDPC codes given a fixed length and rate. Construction of LDPC codes is not unique. It is varied and could be designed with several parameters including length and rate. For LDPC codes to be successfully applied to many applications systems, methods for constructing good codes given a limited block length and other parameters are needed. Constructed codes must also satisfy hardware constraints such as latency, cost, power consumption flexibility and scalability depending on the application. Performance of LDPC codes are determined by some important design factors such as degree distribution, minimum distance, girth, etc. LDPC code construction requires the definition of the pattern of connection between rows and columns of a parity-check matrix or between check and variable nodes of a corresponding Tanner graph. The construction process considers LDPC code parameters such as row and column weights, rate, girth and code length. A code is first designed from which the rate and length are determined before it is constructed. The main objectives in code construction are good decoding performance and easier hardware implementation. An LDPC code could be constructed such that it has low hardware complexity and cost. This is mostly achieved by having row-column connections that have a regular pattern. Good error correcting performance and low complexity hardware characteristics could also be optimized at the same time. However, putting constraints on construction methods to obtain hardware aware codes may degrade or limit decoding performance. The progressive-edge-growth (PEG) algorithm is an efficient method for constructing Tanner graphs with large girth with better performance than randomly constructed codes. PEG algorithm is simple and flexible for constructing
codes from a complex symbol node degree distribution. The performance of these codes can be improved in the error floor region. Significant research in PEG-based algorithms has been done to achieve the improved performance. In PEG, node degrees are distributed according to some performance criteria (e.g. density evolution) before edges are added. The algorithm builds a Tanner graph by connecting the graph’s nodes edge by edge provided the added edge has minimal impact on the girth of the graph. With this algorithm regular and irregular codes can be obtained with optimized performance. It is a simple but efficient method for constructing Tanner graphs having a large girth in a best effort sense by progressively establishing edges between symbol and check nodes in an edge-byedge manner, called progressive edge-growth (PEG) algorithm [3]. Given the number of symbol nodes, the number of check nodes, and the symbol-nodedegree sequence of the graph, an edge-selection procedure is started such that the placement of a new edge on the graph has as small an impact on the girth as possible. After a best effort edge has been determined, the graph with this new edge is updated, and the procedure continues with the placement of the next edge. Simulation results show that the PEG algorithm is a powerful algorithm for generating good regular and irregular LDPC codes of short and moderate block lengths. The significance of the PEG algorithm lies in 1) its simplicity, i.e., its complexity is such that it can easily be used for constructing codes of very large block lengths and good girth guaranteed by the lower bound, and 2) its flexibility, i.e., it successfully generates good codes for any given block length and any rate when using a densityevolution-optimized degree sequence. Moreover, with a slight modification, it can be used to generate linear time-encode able LDPC codes. The rest of this paper has been organized as follows. In Section II, basic concept of PEG algorithm is described. Section III deals with a modified version of the PEG algorithm. In Section IV, EMPEG is discussed. The paper is concluded based on the analysis derived by comparing all these types of PEG algorithms on various aspects such as, length -4 cycle avoidance, encoding, etc.
II. PROGRESSIVE EDGE GROWTH (PEG) ALGORITHM PEG algorithm is one such algorithm in which the local girth of a symbol node is maximized whenever a new edge is added to the symbol node. Given the graph parameters, i.e., the number of symbol nodes n, the number of check nodes m, and the symbol–node–degree sequence Ds, an edgeselection procedure is started such that the placement of a new edge on the graph has as small an impact on the girth as possible. The underlying graph grows in an edge-by-edge manner, optimizing
1832 | P a g e
Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836 each local girth. Accordingly, the resulting Tanner graph is referred to as PEG Tanner graph. The fundamental idea is to find the most distant check node and then to place a new edge connecting the symbol node and the most distant check node. Whenever a sub graph from symbol node sj is expanded before an edge is established, two situations can occur: 1) the cardinality of Nlsj stops increasing but is smaller than m; 2) N¯lsj ≠ Ø, but N¯ l+1 sj = Ø. In the first case, not all check nodes are reachable from sj, so the PEG algorithm chooses the one that is not reachable, thus not creating any additional cycle. This often occurs in the initial phase of graph construction. In the second case, all check nodes are reachable from sj , and the algorithm chooses the one that is at the largest distance from sj , say at depth l+1, so that the cycle created by establishing an edge is of the largest possible length 2(l + 2). The approach can be shown in the figure 2.1 and the algorithm can be summarized as follows: Progressive Edge-Growth Algorithm: for j = 0 to n - 1 do begin for k = 0 to dsj - 1 do begin if k = 0 E0sj ← edge (ci ; sj), where E0sj is the first edge incident to sj and ci is a check node such that it has the lowest check-node degree under the current graph setting Es0 ⋃ Es1 ⋃ … ⋃ Esj-1 . else expand a sub graph from symbol node sj up to depth l under the current graph setting such that the cardinality of Nlsj stops increasing but is less than m , or N¯lsj ≠ Ø but N¯ l+1sj = Ø, then Eksj ← edge (ci ; sj), where Eksj is the kth edge incident to sj and ci is a check node picked from the set N¯lsj having the lowest check-node degree. end end
multiple choices for connecting to symbol node sj, i.e., multiple check nodes exist in N¯lsj, we select the one having the smallest number of incidence edges under the current graph setting. Such a check-node selection strategy renders the resulting PEG Tanner graphs as check-node-degree uniform as possible. So, the generalized PEG algorithm consists of two independent procedures: 1) check nodes shortest paths discovery and 2) check node selection procedure, applied sequentially when adding a new edge to the code graph [4]. Some of the important properties of the PEG algorithm can be discussed as follows: 1) Complexity—In the worst case, the computational complexity and the storage requirements of the PEG algorithm scale as O (nm) and O (n), respectively, whereas the complexity and storage requirements of Gallager’s explicit construction for large girth, in the best case, are both O (n2). 2) Non-greedy version—The version presented above is greedy in the sense that the sub graph spreading from sj proceeds as deep as possible, i.e., the depth l is maximized such that N¯lsj ≠ Ø but N¯ l+1 sj = Ø. However, for long-block-length, low-rate codes, in which the minimum distance is in principle large, it might be favorable to limit l to a certain value lmax, 1) to make the check-node degree sequence concentrated in the strict sense, and 2) possibly to reduce the diameter of the graph. This variant is called the non-greedy PEG algorithm. 3) Look-ahead-enhanced version—In the lookahead-enhanced version, the same procedure as in the greedy PEG algorithm is applied, except when several choices exist for placing the kth edge of sj. In this case, additional testing is introduced to ensure that a better choice is used. 4) Flexibility and scalability—The PEG algorithm can be used to construct regular and irregular bipartite graphs with arbitrary size. It generates good codes for any given block length and rate, provided a good degree sequence is supplied. Its low complexity makes it suitable for constructing codes of very large lengths and, with a slight modification, for constructing linear-time-encoding LDPC codes. By incorporating an extra criterion called ―approximate cycle-extrinsic message degree (ACE)‖ at the stage of selecting one check node from the set N¯lsj , the error floor at high SNRs for irregular PEG codes can be further improved.
III. MODIFIED PROGRESSIVE GROWTH ALGORITHMS
Fig.2.1: Spanning Tree. There is a subtle point in the PEG algorithm that needs further comment. Whenever we encounter
EDGE
A PEG-based algorithm consists of two basic procedures: a local graph expansion and a check node selection procedure. Both procedures are executed sequentially in order to construct a Tanner graph connecting symbol and check nodes in an edge-by-edge manner. With a slight modification to the original PEG algorithm, some variations in the
1833 | P a g e
Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836 results to the previous algorithm can be obtained [4]. The edge selection procedure used in this proposal differs from the selection procedure proposed in the original PEG algorithm. The graph is analyzed to avoid local short cycles, however check nodes are not chosen according to its number of assigned edges, dk(ci ), i.e. its current (or partial) degree. Instead of this, the check node with the highest difference between its partial and finaldefined degree is chosen, f(ci ) = d(ci )−dk(ci ), i.e. the difference between the number of currently assigned edges and the total number of edges to be assigned. The lowest check node degree procedure is replaced by a highest free check node degree (FCD) procedure (see Fig. 3.1). The FCD concept, comes from the concept of ―sockets‖ previously described in [11].
Figure 3.1 Tanner Graphs characteristics of the algorithm.
illustrating
some
Here, d(sj) is the sj symbol node degree (The number of incident edges. It corresponds to the cardinality of the ensemble Esj after the code construction), d(ci ) is the ci check node degree, f(ci ) is the number of edges that can be added to the check node cj under the current graph setting, such that dk(ci ) = f(ci )−d(ci ), Esj is the ensemble of edges connected to the symbol node sj , Eksj the edge added in the step k of the progressive construction, and Nlsj is the ensemble of nodes reached after the graph expansion from the symbol node sj up to depth l. A zig-zag construction for 2-degree symbol nodes (see Fig. 3.1) is forced by using a special criterion when adding the first edge to a symbol node. In this particular selection, a list of eligible check nodes is limited to those check nodes already connected under the current graph setting, Es′ = Es1 ∪ Es2 ∪ · · · ∪ Esj−1 , i.e. to the list of check nodes that have been chosen at least once from the first to j-th step. This construction is used to avoid cycles with 2-degree symbol nodes, thus obtaining a good performance in the error floor region. Modified Progressive Edge-Growth (PEG) Algorithm: Require: d(si ) ≤ d(sj) ∀i < j and f(ci ) = d(ci ) ∀i for j = 1 to n do
for k = 1 to d(sj) do if k = 1 then if d(sj) = 2 then E1sj ← (ci, sj), where E1sj is the first edge incident to sj and ci is a check node such that it has the lowest check-node degree under the current graph setting Es1 ∪ Es2 ∪ ・ ・ ・ ∪ Esj−1 . else E1sj ← (ci, sj), where E1sj is the first edge incident to sj and ci is a check node such that it has the highest free check-node degree. end if else Expand a subgraph from symbol node sj up to depth l under the current graph setting, such that Nlsj = Nl+1sj, or N¯lsj ≠ Ø but N¯ l+1sj = Ø. Eksj ← (ci, sj), where Eksj is the kth edge incident to sj and ci is a check node picked from the set N¯lsj having the highest free check-node degree. end if f(ci ) = f(ci ) − 1 end for end for This is an improved PEG algorithm. The constructed codes comply with both an irregular check and an irregular symbol degree distribution. Simulation results show that this method behaves very well in the waterfall region while also maintaining a low error floor. Good performance in both regions is relevant as it allows to use the same code independently of the working point, e.g. this construction might find application in rate compatible solutions.
IV. ERROR-MINIMIZATION PROGRESSIVE EDGE GROWTH (EMPEG) ALGORITHM It’s an improved version of the PEG algorithm mainly aimed at the BEC, but also performs well on other channel types, such as AWGN channel. It’s an algorithm for constructing codes with good finite length performance and low error-floors over BEC. This algorithm is a greedy PEG type algorithm which generates the edges in the graph one by one. This algorithm directly optimizes the code’s block error probability over BEC. It directly tries to optimize the code’s error performance by exploiting the knowledge about a certain type of combinatorial structure, namely minimal cycle sets. Each edge placed by the EMPEG algorithm is chosen in such a way as to minimize the contribution to the expected block error probability. This contribution can be calculated by enumerating the minimal cycle sets that are formed in the edge in question is added to the graph. In order to continue, some basic definitions need to be introduced. Definition 4.1 (Extrinsic Check Node): An extrinsic check node to a set of variable nodes is a check node which is singly connected to the set.
1834 | P a g e
Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836 Definition 4.2 (Intrinsic Check Node): An intrinsic check node to a set of variable nodes is a check node which is connected to the set at least twice. Definition 4.3 (Extrinsic Message Degree (EMD)): EMD of a set of variable nodes is the number of extrinsic check nodes connected to the set. The EMD of a path in the graph is the EMD of the set of variable nodes contained in that path. Accordingly, the EMD of a cycle in the graph is the EMD of the set of variable nodes contained in that cycle. Definition 4.4 (Stopping Set): A stopping set S is a subset of the set of variable nodes V, such that no extrinsic check nodes are connected to S. Definition 4.5 (Minimal Cycle): A set of variable nodes forms a minimal cycle if: 1) it forms a cycle 2) no subset of the variable nodes forms a cycle. Definition 4.6 (Cycle Set): A (d, ω, τ) cycle set is a set of the d variable nodes which forms a minimal cycle and has ω intrinsic check nodes and τ extrinsic check nodes. Definition 4.7 (Minimal Cycle with respect to the edge e): A set of variable nodes forms a minimal cycle with respect to the edge e if: 1) it forms a cycle that contains e 2) no subset of the variable nodes forms a cycle that contains e. Definition 4.8 (e-Cycle Set): A (d, ω, τ) e-cycle set is a set of d variable nodes, which forms a minimal cycle with respect to e and has ω intrinsic check nodes and τ extrinsic check nodes. Definition 4.9 (Minimal e-Cycle Set): A (d, τ) minimal e-cycle set is an e-cycle set, such that there is no other (d’, τ’) e-cycle set for which (d’, τ’) < (d, τ). Enumeration of e-cycle sets, which is vital to the EMPEG algorithm, has high complexity. Minimal e-cycle sets provide the highest contribution to the expected block error probability, so they are enumerated instead of enumerating all possible e-cycle sets. After minimal e-cycles have been enumerated, an estimate of their expected contribution to the block error probability has to be calculated. Let Pєcs (d, τ) and Pєcs(d, ω, τ) denote an upper bound on the expected contribution to the block error probability of a given (d, τ) cycle set and (d, ω, τ) e-cycle set over BEC with erasure probability є, respectively. We compute Pєcs using the union bound. Pєcs(d, ω, τ) = ∑Ns=d (d, ω, τ)єs (1) Pєcs (d, τ) = Pєcs (d, d, τ) (2) Here, Ns(d, ω, τ) is the expected number of stopping sets of size s which contain the given (d, ω, τ)-cycle set. EMPEG Algorithm [5]: Previously known graph generation algorithms try to produce codes with good finite length performance by conditioning the girth, or the ACE in the graph. Both these criteria do not always
provide the best choice with respect to the expected block error probability. Unlike these approaches the suggested algorithm directly minimizes the expected block error probability. The EMPEG algorithm is a greedy progressive edge growth algorithm which generates the graph edges one by one, each time choosing the edge with the smallest contribution to the expected block error probability. More specifically, the EMPEG algorithm generates a graph G = (V, C, E) from a given ensemble ensemble G (Λ(x), P(x)). The ensemble parameters can be optimized via standard asymptotic analysis and design tools. The algorithm is initialized with an unconnected graph G, where V and C are assigned with edge sockets according to Λ(x) and P(x) respectively and E = ∅. The graph edges are then generated according to the following algorithm: While there exists a variable node vi ∈ V with unconnected sockets do: 1) For every check node cj with an unconnected socket: a) Enumerate (minimal) e-cycle sets that will be formed if the edge e = (vi, cj) is connected. b) Compute an estimate PB(G, e, є) of the expected contribution of e = (vi, cj) to the block error probability of the code over a BEC with erasure probability є. 2) Choose an edge, randomly, from the set of edges for which PB is minimal. Connect the chosen edge in the graph G. The cycle sets enumeration in step 1, can be done simultaneously for all possible edges, based on a single tree spanning procedure. Enumerating all ecycle sets requires high memory complexity, since many e-cycle sets should be tracked. However, enumerating only the minimal e-cycle sets, which provide the most essential contribution to the block error probability. In general, when generating an edge incident to variable node vi, we span the current graph as a tree originating from vi and store the depth, EMD and multiplicity of all paths from vi to every check node cj that can result in a minimal ecycle set. A path from variable node vi to node n can lead to a minimal e-cycle set if there is no path from vi to n of shorter length with smaller or equal EMD. We refer to such a path as a minimal path. As the depth of the spanned tree increases the number of minimal paths that are tracked decreases fast. Minimal paths of increasing depth and decreasing EMD become more and more scarce. Once all minimal paths are exposed we can stop spanning the tree. Due to the progressive edge growth construction nature of the algorithm, it is easy to impose various structural limitations on the generated graph, and also various non-greedy variants of the EMPEG algorithm can be implemented. The EMPEG graph generation consists of |E|=N.dv edge generation steps, where dv is the average variable node degree. Each step
1835 | P a g e
Sandip J. Sukhdeve, Rahul Kamdi, Dr. R. N. Awale, D. P. Rathod / International Journal of Engineering Research and Applications (IJERA) ISSN: 2248-9622 www.ijera.com Vol. 3, Issue 2, March -April 2013, pp.1831-1836 requires running the e-cycle sets enumeration procedure, which involves tree spanning for tracking all minimal paths. During tree spanning every edge in the current graph can be traversed at most once. Hence the EMPEG requires at most O(N2) operations. The space complexity required for the enumeration step is O(N· log (N)). The EMPEG code is expected to exhibit lower error floor. While the PEG graph does not contain length 4 cycles, the EMPEG graph contain many length 4 cycles. Hence, the common belief that the length 4 cycles are harmful and should be removed from the code’s graph is not always true.
[2]
V. CONCLUSION
[5]
[3]
[4]
The following table sums up the basic properties of each construction method presented here. Table 1. Code Construction Properties. [6] [7]
The comparison of the different PEG based LDPC Codes construction methods have been discussed here. Comparing these algorithms for the construction of LDPC codes, we find that the Modified PEG and EMPEG algorithms are the improved versions of the PEG algorithm. The codes generated using the EMPEG algorithm provide better performance compared to previously known code generation algorithm. They are efficient in length-4 cycle avoidance, rate guarantee, quick encoding and irregularity of the LDPC Codes. EMPEG algorithm applies mainly to the BEC channel whereas the Modified PEG can be applied to any channel (BEC, BSC or AWGN) for the better communication.
[8]
[9] [10]
[11]
J. C. MacKay, ―Good error-correcting codes based on very sparse matrices,‖ IEEE Trans. Inform. Theory, vol. 45, pp. 399– 432, Mar. 1999. X.-Y. Hu, E. Eleftheriou, and D.-M. Arnold, ―Regular and irregular progressive edge-growth tanner graphs,‖ IEEE Trans. Inf. Theory, vol. 51, no. 1, pp. 386–398, Jan. 2005. H. Xiao and A. Banihashemi, ―Improved progressive-edge-growth (PEG) construction of irregular LDPC codes,‖ IEEE Commun. Lett., vol. 8, no. 12, pp. 715–717, Dec. 2004. Eran Sharon, Student Member, IEEE, and Simon Litsyn, Senior Member, IEEE ―Constructing LDPC Codes by Error Minimization Progressive Edge Growth‖ IEEE TRANSACTIONS ON COMMUNICATIONS, VOL. 56, NO. 3, MARCH 2008. Simon Haykins, ―Communication Systems‖, 4th Edition, 2000. D. J. C. MacKay, ―Repository of LDPC codes,‖ see: http://www.inference.phy.cam.ac.uk/macka y/codes/data.html S. Lin and D. Costello. Error-Control Coding: Fundamentals and Applications. Prentice-Hall, 2nd edition, 2004. T. Richardson and R. Urbanke, ―Modern Coding Theory‖, Cambridge 2003. T. Tian, C. Jones, J. D. Vilasenor, and R. D. Wesel, ―Construction of irregular LDPC codes with low error floors,‖ in Proc. IEEE Int. Conf. Commun., vol. 5, Anchorage, AK, May 2003, pp. 3125–3129. T. Richardson and R. Urbanke, ―The capacity of low-density parity-check codes under message-passing decoding,‖ IEEE Tr ans. Inform. Theory, vol. 47, pp. 599–618, Feb. 2001.
REFERENCES [1]
R.G. Gallager. Low-Density Parity-Check Codes. Cambridge MA: MIT Press, 1963.
1836 | P a g e