Improved progressive edgegrowth algorithm for fast encodable LDPC codes
 Xueqin Jiang^{1, 2}Email author,
 Moon Ho Lee^{3} and
 Jinpeng Qi^{1, 2}
https://doi.org/10.1186/168714992012178
© Jiang et al; licensee Springer. 2012
Received: 14 May 2011
Accepted: 21 May 2012
Published: 21 May 2012
Abstract
The progressive edgegrowth (PEG) algorithm is known to construct lowdensity paritycheck (LDPC) codes at finite code lengths with large girths by establishing edges between symbol and check nodes in an edgebyedge manner. The linearencoding PEG (LPEG) algorithm, a simple variation of the PEG algorithm, can be applied to generate linear time encodable LDPC codes whose m parity bits p_{1}, p_{2}, ..., p_{ m }are computed recursively in m steps. In this article, we propose modifications of the LPEG algorithm to construct LDPC codes whose number of encoding steps is independent of the code length. The maximum degree of the symbol nodes in the Tanner graph is denoted by ${d}_{s}^{\mathsf{\text{max}}}$; The m parity bits of the proposed LDPC codes are divided into ${d}_{s}^{\mathsf{\text{max}}}$ subgroups and can be computed in only ${d}_{s}^{\mathsf{\text{max}}}$ steps. Since ${d}_{s}^{\mathsf{\text{max}}}\ll m$, the number of encoding steps can be significantly reduced. It has also been proved that the PEG codes and the codes proposed in this article have similar lower bound on girth. Simulation results showed that the proposed codes perform very well over the AWGN channel with an iterative decoding.
1 Introduction
Lowdensity paritycheck (LDPC) codes, which were first proposed in the early 1960's [1] and rediscovered in 1996 [2], have recently attracted much attention due to their capacityapproaching performance and low decoding complexity. Since their rediscovery, there are many methods such as the messagepassing decoding and the linear program decoding [3, 4] that have been proposed for the decoding algorithm. Also many other methods have been proposed for the construction algorithm [5–8]. Among the existing methods, the most successful approach for the construction of LDPC codes is the progressiveedgegrowth (PEG) algorithm [5, 6]. The PEG construction builds up a Tanner graph, equivalent to a paritycheck matrix, for an LDPC code in an edgebyedge manner and maximizes the local girth at symbol nodes in a greedy algorithm. It is simple and flexible in that it can be applied in constructing codes of arbitrary length and rate. In addition, the PEG algorithm can be modified to construct linear time encodable LDPC codes. In this article, this modified algorithm is referred to as linearencoding PEG (LPEG) algorithm. Initially, the paritycheck matrix was used in decoding process for LDPC codes. But it can also be used for the encoding of LDPC codes [9]. LDPC codes with m parity bits constructed by the LPEG algorithm can be encoded with the paritycheck matrix in m recursive steps [6]. Therefore, for a given code rate R, the number of encoding steps of LPEG codes grows linearly with the code length n = m/(1R).
The objective of this article is to reduce the number of encoding steps of the LPEG codes with negligible performance loss. To reduce the number of encoding steps, we modified the LPEG algorithm to obtain two new algorithms which are referred to as fastencoding PEG (FPEG) algorithm and modified FPEG (MFPEG) algorithm, respectively. ${d}_{s}^{\mathsf{\text{max}}}$ is used to denote the maximum degree of symbol nodes. The number of encoding steps of the FPEG codes grows linearly with ${d}_{s}^{\mathsf{\text{max}}}$, but not the code length n. The number of encoding steps of the MFPEG codes grows linearly with $\left({d}_{s}^{\mathsf{\text{max}}}+\u230a\frac{m}{{d}_{s}^{\mathsf{\text{max}}}}\u230b1\right)$. Since ${d}_{s}^{\mathsf{\text{max}}}$ is much smaller than m, the number of encoding steps of FPEG codes or MFEPG codes is lower than that of the LPEG codes. Moreover, to ensure that there is negligible performance loss, we proved that the PEG codes and our codes had similar lower bound on girth. This was confirmed by providing examples of the proposed codes and comparing their performance with that of the multiple serially concatenated multiple paritycheck (MSCMPC) code, which is a class of LDPC codes of efficient encoding [10].
The remainder of this article is organized as follows. Section 2 reviews the PEG algorithm and the LPEG algorithm. Section 3 proposes the FPEG algorithm and the MFPEG algorithm. A lower bound on the girth of the FPEG algorithm is also derived in this section. Section 4 presents two examples of FPEG codes and MFPEG codes and demonstrates their performances. Finally, Section 5 concludes the article.
2 Preliminary
2.1 Progressive edgegrowth algorithm
An LDPC code is a linear block code defined by a sparse paritycheck matrix H having dimension m × n. A bipartite graph with m check nodes in one class and n symbol nodes in the other can be created using H as the integervalued incidence matrix for the two classes. Such a graph is also called a Tanner graph [11]. Let V_{ c }= {c_{0}, c_{1}, ..., c_{ m  }_{1}} denote the set of check nodes and V_{ s }= {s_{0}, s_{1}, ..., s_{ n }_{1}} denote the set of symbol nodes. E is the set of edges such that E ⊆ V_{ c }× V_{ s }, with edge (c_{ i }, s_{ j }) ∈ E if and only if h_{ i,j }≠ 0, where h_{ i,j }denotes the entry of H at the i th row and j th column, 0 ≤ i ≤ m  1, 0 ≤ j ≤ n  1. The PEG algorithm for constructing a Tanner graph with n symbol nodes and m check nodes is described in Algorithm 1. In this algorithm, both symbol nodes and check nodes are ordered according to their degrees in a nondecreasing order. ${d}_{{s}_{j}}$ is the degree of symbol node ${s}_{j},{N}_{{s}_{j}}^{l}$, and ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}$ denote the set of all check nodes reached by a tree spreading from symbol node s_{ j }with in depth l, and its complement, respectively [6]. It was proved that [4] the PEG algorithm constructs Tanner graphs having a large girth and the lower bound on the girth was proved to be
Algorithm 1. PEG algorithm
1: for j = 0 to n  1 do
2: for k = 0 to ${d}_{{s}_{j}}1$do
3: if k = 0 then
${E}_{{s}_{j}}^{0}$ ← edge (c_{ i }, s_{ j }), where ${E}_{{s}_{j}}^{0}$ is the first edge incident to s_{ j }and c_{ i }is a check node such that it has the lowest checknode degree under the current graph setting ${E}_{{s}_{0}}\cup {E}_{{s}_{1}}\cup \cdots \cup {E}_{{s}_{j1}}$.
4: else
expand a subgraph from s_{ j }up to depth l under the current graph setting such that the cardinality of ${N}_{{s}_{j}}^{l}$ stops increasing but is less than m, or ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l+1}\ne \varnothing $ but ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l+1}\ne \varnothing $, then ${E}_{{s}_{j}}^{k}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{i},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{k}$ is the k th edge incident on s_{ j }and c_{ i }is a check node picked from ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}$ having the lowest checknode degree.
5: end if
6: end for
where ${d}_{c}^{\mathsf{\text{max}}}$ and ${d}_{s}^{\mathsf{\text{max}}}$ were the maximum degrees of the check nodes and symbol nodes, respectively.
2.2 Linearencoding PEG algorithm
where the m × m component ${H}^{p}={h}_{i,j}^{p}$ of the paritycheck matrix is forced to have the upper
Accordingly, the symbol node set V_{ s }in the Tanner graph is partitioned into redundant subset ${V}_{s}^{p}$ and the information subset ${V}_{s}^{d}$, which contain the first m symbol nodes and the other n  m symbol nodes, respectively. The edges of the symbol nodes are then established by means of the LPEG algorithm which constructs an upper triangular pattern. As the procedure of establishing the edges of n  m information bits follows the construction of edges of ${V}_{s}^{p}$ and is exactly the same as the PEG algorithm described in Algorithm 1, only the LPEG algorithm for constructing edges of ${V}_{s}^{p}$ is shown in Algorithm 2.
Algorithm 2. LPEG algorithm for Establishing Edges of ${V}_{s}^{p}$
1:for j = 0 to m  1 do
2: for k= 0 to ${d}_{{s}_{j}}1$do
3: if k = 0 then
${E}_{{s}_{j}}^{0}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{j},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{0}$ is the first edge incident to s_{ j }. This edge corresponds to the "1" in the diagonal line of matrix H^{ p }.
4: else
expand a subgraph from s_{ j }up to depth l under the current graph setting such that ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}\cap \left\{{c}_{0},{c}_{1},\dots ,{c}_{j1}\right\}\ne \varnothing $ but ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l+1}\cap \left\{{c}_{0},{c}_{1},\dots ,{c}_{j1}\right\}=\varnothing $, or the cardinality of ${N}_{{s}_{j}}^{l}$ stops increasing, then ${E}_{{s}_{j}}^{k}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{i},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{k}$ is the k th edge incident to s_{ j }and c_{ i }is a check node picked from the set ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}\cap \left\{{c}_{0},{c}_{1},\dots ,{c}_{j1}\right\}$ having the lowest checknode degree.
5: end if
6: end for
7: end for
Note that the first column of H^{ p }corresponds to a degree1 symbol node and the fraction of degree1 symbol node is 1/n. It was proved that the Tanner graph of an upper or lower triangular paritycheck matrix could be equivalently transformed into a pseudotree and the corresponding LDPC codes could also be encoded in a linear number of steps by the labelanddecide algorithm [12].
2.3 MSCMPC codes
3 FPEG algorithm and MFPEG algorithm
In the following section, we introduce an FPEG algorithm and an MFPEG algorithm used to construct an upper triangular paritycheck matrix.
3.1 FPEG algorithm
This is a rate R = 0.5 and length n = 12 paritycheck matrix that corresponds to an LDPC code C = [p_{1}, p_{2}, ..., p_{6}, d_{1}, d_{2}, ..., d_{6}], where d_{1}, d_{2}, ..., d_{6} are the information bits and p_{1}, p_{2}, ..., p_{6} are the parity bits. This is by no means a good LDPC code but it is an example. The paritycheck matrix H in (10) can be divided into three 2 × 12 submatrices H_{1}, H_{2} and H_{3}. In each submatrix H_{ i }, the rows do not have '1's in the same column. Then, the encoding of C includes the following three steps:
 (A)
The paritycheck matrix H should contain an upper triangular pattern.
 (B)
The r_{ i }rows in each submatrix H_{ i }should not have '1's in the same column.
 (C)
The number of submatrices should not be smaller than the maximum symbolnode degree $\left(M={d}_{s}^{\mathsf{\text{max}}}\right)$.
Condition (A) guarantees that the corresponding codes are linear time encodable [12]. Condition (B) guarantees that the r_{ i }paritycheck equations in submatrix H_{ i }can be used to generate r_{ i }parity bits simultaneously [10, 13, 14] while condition (C) is a necessary condition for condition (B). Observing these three conditions, the Tanner graph of the paritycheck matrix H can be constructed with the proposed FPEG algorithm.
Algorithm 3. FPEG algorithm for establishing edges of ${V}_{s}^{p}$ and ${V}_{s}^{d}$
1: for j = 0 to n  1 do
2: if j < m then
3: SC = {c_{0}, c_{1}, ..., c_{j1}}.
4: else
5: SC = {c_{0}, c_{1}, ..., c_{n1}}.
6: end if
7: for k = 0 to ${d}_{{s}_{j}}1$do
8: if k = 0 then
9: if j < m then
${E}_{{s}_{j}}^{0}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{j},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{0}$ is the first edge incident to s_{ j }. This edge corresponds to the "1" in the diagonal line of matrix H^{ p }.
10: else
${E}_{{s}_{j}}^{0}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{j},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{0}$ is the first edge incident to s_{ j }and c_{ i }is a check node such that it has the lowest checknode degree under the current graph setting ${E}_{{s}_{0}}\cup {E}_{{s}_{1}}\cup \cdots \cup {E}_{{s}_{j1}}$.
11: end if
12: else
expand a subgraph from s_{ j }up to depth l under the current graph setting such that ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}\cap SC\ne \varnothing $ but ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l+1}\cap SC=\varnothing $, or the cardinality of ${N}_{{s}_{j}}^{l}$ stops increasing, then ${E}_{{s}_{j}}^{k}\leftarrow \mathsf{\text{edge}}\phantom{\rule{2.77695pt}{0ex}}\left({c}_{i},{s}_{j}\right)$, where ${E}_{{s}_{j}}^{k}$ is the k th edge incident to s_{ j }and c_{ i }is a check node picked from the set ${\stackrel{\u0304}{N}}_{{s}_{j}}^{l}\cap SC$ having the lowest checknode degree.
13: end if
14: Find out which check node group G_{ i }includes c_{ i }. SC ← SC\G_{ i }.
15: end for
16: end for
for i ∈ {1, 2, ..., M}. When the condition (17) is satisfied, it was proved that, given a symbolnodedegree distribution, for large code lengths, the probability of failing to construct an approximate upper or lower triangular paritycheck matrix was negligible [15] (Theorem 1).
where ⌊⋅⌋ denotes the flooring operation,$J={r}_{\mathsf{\text{min}}}\left({d}_{s}^{\mathsf{\text{max}}}1\right)+1$and r_{min}is the minimum of {r_{1}, r_{2}, ..., r_{ M }}.
The proof is completed.
is achieved when $M={d}_{s}^{\mathsf{\text{max}}}$. Therefore, the maximum g_{ F }is achieved when $M={d}_{s}^{\mathsf{\text{max}}}$.
Note that there are degree1 symbol nodes in the corresponding FPEG Tanner graph and the fraction of degree1 symbol nodes is r_{1}/n. The existence of degree1 symbol nodes is a necessary condition for a linearencoding algorithm such as the labelanddecide algorithm and the LPEG algorithm [5, 12]. However, it was stated that the outbound extrinsic messages of degree1 nodes would not be updated during the iterative decoding process [16, 17]. Consequently, the degree1 symbol nodes would cause many problems such as mismatching of extrinsic information transfer (EXIT) functions and the halting of mutual information evolution. In the following section, we will introduce a modified FPEG algorithm, which construct LDPC codes with only one degree1 symbol node.
3.2 MFPEG algorithm
A simple modification of the FPEG algorithm can be applied to construct LDPC codes which have only one degree1 symbol node. This modified algorithm is called MFPEG algorithm in this article. The MFPEG algorithm is almost the same as the Algorithm 3 except for line 14. Therefore, we only describe the modified part in Algorithm 4.
Algorithm 4. MFPEG algorithm
1: Find out which check node group G_{ i }includes c_{ i }.
4: end if
where g_{ M }is the lower bound on girth of the MFPEG Tanner graph.
4 Examples and simulation results
In this section, we provide two examples of the proposed codes and compare them with the MSCMPC codes [10] and LPEG codes. In this article, we denote LPEG codes, FPEG codes and MFPEG codes with M submatrices by MLPEG codes, MFPEG codes, and MMFPEG codes respectively. In the first example it is shown that, In comparison to the MSCMPC codes which have the same number of encoding steps as FPEG codes, FPEG codes have better error correcting performance. In the second example, it is shown that for a given symbolnodedegree distribution, FPEG codes and MFPEG codes have similar error correcting performance but less encoding steps. In computing the error correcting performance, in terms of the bit error rate (BER), we assume BPSK transmission over the AWGN channel. The decoding algorithm used here is the loglikelihood sumproduct algorithm and the maximum iteration number is set to be 50.
Example 2: An MSCMPC code consists of M MPC encoders and offers a flexible code rate and code length with low encoding complexity [10]. The encoding process of an MSCMPC code includes M steps, where M is also the maximum symbolnode degree, ${d}_{s}^{\mathsf{\text{max}}}$. Clearly, for the same maximum symbolnode degree, the number of encoding steps of MSCMPC codes is the same as those of FPEG codes. Therefore, we will compare the performance of FPEG codes and MSCMPC codes, provided that the number of encoding steps and the symbolnodedegree distributions are the same.
For the rate 3/4, in [10], the authors considered the following MSCMPC codes:

4SCMPC: n = 1196, r_{1} = 59, r_{2} = 73, r_{3} = 78, r_{4} = 89;

5SCMPC: n = 1268, r_{1} = 53, r_{2} = 55, r_{3} = 59, r_{4} = 67, r_{5} = 83;

6SCMPC: n = 1204, r_{1} = 45, r_{2} = 46, r_{3} = 47, r_{4} = 49, r_{5} = 53, r_{6} = 61.
Symbolnodedegree distributions of the MSCMPC codes
Code  λ _{1}  λ _{2}  λ _{3}  λ _{4}  λ _{5}  λ _{6} 

4SCMPC  0.0744  0.0652  0.0610  0.7993  
5SCMPC  0.0655  0.0528  0.0465  0.0434  0.7918  
6SCMPC  0.0510  0.0440  0.0410  0.0390  0.0382  0.7874 
Checknodedegree distributions of MSCMPC codes
Code  ρ _{13}  ρ _{14}  ρ _{15}  ρ _{16}  ρ _{17}  ρ _{18}  ρ _{19}  ρ _{20}  ρ _{21}  ρ _{22}  ρ _{23} 

4SCMPC  0.1672  0.5618  0.0736  0.1572  0.0401  
5SCMPC  0.1893  0.0726  0.0662  0.1640  0.4637  0.0442  
6SCMPC  0.0532  0.1495  0.2757  0.4585  0.0631 
Original symbolnodedegree distribution in [18]
${d}_{s}^{max}$  ψ _{2}  ψ _{3}  ψ _{4}  ψ _{5}  ψ _{6} 

4  0.3835  0.0424  0.5741  
5  0.3266  0.1196  0.1840  0.3699  
6  0.3324  0.2463  0.1102  0.3111 
New symbolnodedegree distribution
Code  ${\psi}_{1}^{*}$  ${\psi}_{2}^{*}$  ψ _{3}  ψ _{4}  ψ _{5}  ψ _{6} 

4LPEG  0.0010  0.3825  0.0424  0.5741  
5LPEG  0.0010  0.3455  0.1196  0.1840  0.3699  
6LPEG  0.0010  0.3314  0.2463  0.1102  0.3111  
4FPEG  0.1250  0.2585  0.0424  0.5741  
5FPEG  0.1000  0.2466  0.1196  0.1839  0.3699  
6FPEG  0.0830  0.2594  0.2463  0.1102  0.3111  
4MFPEG  0.0010  0.3825  0.0424  0.5741  
5MFPEG  0.0010  0.3455  0.1196  0.1840  0.3699  
6MFPEG  0.0010  0.3314  0.2463  0.1102  0.3111 
Girth lower bound, girth and average cycle length for m = 500, n = 1000, and R = 0.5
Code  ${d}_{c}^{max}$  Girth  Lower bound  Average cycle length 

4LPEG  8  7  6  8.02 
5LPEG  6  8  6  7.99 
6LPEG  6  8  6  7.486 
4FPEG  6  7  6  7.49 
5FPEG  6  8  6  7.308 
6FPEG  6  8  6  7.126 
4MFPEG  6  7  6  8.142 
5MFPEG  6  8  6  7.876 
6MFPEG  6  8  6  7.532 
Number of encoding steps For m = 500, n = 1000, and R = 0.5
${d}_{s}^{max}$  T_{ L }(LPEG)  T_{ F }(FPEG)  T_{ M }(MFPEG) 

4  500  4  128 
5  500  5  104 
6  500  6  88 
5 Conclusion
In this article, we introduced the FPEG algorithm and the MFPEG algorithm for generating fast encodable LDPC codes. The number of encoding steps of the FPEG codes grows linearly with ${d}_{s}^{\mathsf{\text{max}}}$, not the code length n. The number of encoding steps of the MFPEG codes grows linearly with $\left({d}_{s}^{\mathsf{\text{max}}}+\u230a\frac{m}{{d}_{s}^{\mathsf{\text{max}}}}\u230b1\right)$. Moreover, we derived a lower bound on girth of the FPEG codes which is shown to be similar to that of PEG codes. By examples and simulations, it is shown that compared to the MSCMPC codes the FPEG codes have the same number of encoding steps but better error correcting performance, and compared to the LPEG codes the FPEG codes have similar error correcting performance but less encoding steps. Variants of MSCMPC codes, in which the degree of freedom is exploited, have been proposed in [20, 21]. Considering these variants of MSCMPC codes in the design of fastencodable LDPC codes is an open issue for future research.
Declarations
Acknowledgements
This study was supported by World Class University (R322008000200140) NRF, Korea. It was also supported partly by the National Nature Science Foundation of China (61104154), Specialized Research Fund for Natural Science Foundation of Shanghai (10ZR1401600) and Fundamental Research Funds for the Central Universities (11D10417).
Authors’ Affiliations
References
 Gallager RG: Low density parity check codes. IEEE Trans Inf Theory 1962, IT8(1):2128.MathSciNetView ArticleMATHGoogle Scholar
 MacKay DJC, Neal RM: Near Shannon limit performance of low density parity check codes. IEE Electron Lett 1996, 32(18):16451646. 10.1049/el:19961141View ArticleGoogle Scholar
 Feldman J, Wainwright MJ, Karger DR: Using linear programming to decode binary linear codes. IEEE Trans Inf Theory 2005, 51(3):954972. 10.1109/TIT.2004.842696MathSciNetView ArticleMATHGoogle Scholar
 Taghavi N MH, Siegel PH: Adaptive methods for linear programming decoding. IEEE Trans Inf Theory 2008, 54(12):53965410.MathSciNetView ArticleMATHGoogle Scholar
 Hu XY, Eleftheriou E, Arnold DM: Progressive edgegrowth Tanner graphs. In IEEE Global Telecommunications Conf. (GLOBECOM). Volume 2. San Antonio, TX; 2001:9951001.View ArticleGoogle Scholar
 Hu XY, Eleftheriou E, Arnold DM: Regular and irregular progressive edgegrowth Tanner graphs. IEEE Trans Inf Theory 2005, 51(1):386398.MathSciNetView ArticleMATHGoogle Scholar
 Jiang X, Lee MH: Large girth quasicyclic LDPC codes based on the chinese remainder theorem. IEEE Commun Lett 2009, 13(5):342344.View ArticleGoogle Scholar
 Jiang X, Lee MH: Large girth nonbinary LDPC codes based on Euclidean geometries and finite fields. IEEE Signal Process Lett 2009, 16(6):521524.View ArticleGoogle Scholar
 Haley D, Grant A, Buetefuer J: Iterative encoding of lowdensity paritycheck codes. In IEEE Globecom 2002. Volume 2. Taipei, Taiwan, Roc; 2002:12891293.Google Scholar
 Baldi M, Cancellieri G, Carassai A, Chiaraluce F: LDPC codes based on serially concatenated multiple paritycheck codes. IEEE Commun Lett 2009, 13(2):142144.View ArticleGoogle Scholar
 Tanner RM: A recursive approach to low complexity codes. IEEE Trans Inf Theory 1981, IT27(6):533547.MathSciNetView ArticleMATHGoogle Scholar
 Lu J, Moura JMF: Linear time encoding of LDPC codes. IEEE Trans Inf Theory 2010, 56(1):233249.MathSciNetView ArticleGoogle Scholar
 Jiang X, Lee MH: Semirandom LDPC codes with efficient encoding. IEE Electron Lett 2009, 45(24):12591260. 10.1049/el.2009.2314View ArticleGoogle Scholar
 Tee JSK, Taylor DP, Martin PA: Multiple serial and parallel concatenated single paritycheck codes. IEEE Trans Commun 2003, 51(10):16661675. 10.1109/TCOMM.2003.818085View ArticleGoogle Scholar
 Freundlich S, Burshtein D, Litsyn S: Approximately lower triangular ensembles of LDPC codes with linear encoding complexity. IEEE Trans Inf Theory 2007, 53(4):14841494.MathSciNetView ArticleMATHGoogle Scholar
 Yue G, Ping L, Wang X: Generalized lowdensity paritycheck codes based on Hadamard constraints. IEEE Trans Inf Theory 2007, 53(3):10581079.MathSciNetView ArticleMATHGoogle Scholar
 GarciaFrias J, Zhong W: Approaching Shannon performance by iterative decoding of linear codes with lowdensity generator matrix. IEEE Commun Lett 2003, 7(6):266268.View ArticleGoogle Scholar
 Richardson T, Shokrollahi MA, Urbanke R: Design of capacityapproaching irregular lowdensity paritycheck codes. IEEE Trans Inf Theory 2001, 47(2):619637. 10.1109/18.910578MathSciNetView ArticleMATHGoogle Scholar
 Weng W, Ramamoorthy A, Wesel R: Lowering the error floors of irregular highrate ldpc codes by graph conditioning. In VTC. Volume 4. Los Angeles, California; 2004:25492553.Google Scholar
 Baldi M, Cancellieri G, Chiaraluce F, De Amicis A: Design of permuted serially concatenated multiple paritycheck codes. In Proc SoftCOM. Volume 1. Split, Croatia; 2010:285289.Google Scholar
 Baldi M, Cancellieri G, Chiaraluce F, De Amicis A: Irregular MSCMPC codes for wireless applications. In Proc 2010 European Wireless Conference, EW. Volume 1. Lucca, Italy; 2010:369376.View ArticleGoogle Scholar
Copyright
This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/2.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.