CN101248583A - 通信装置以及解码方法 - Google Patents

Abstract

本发明的通信装置是把被LDPC编码过的码字进行解码的接收一侧的通信装置，具备保持解码的中间结果的中间结果保持部(21)；对于检验矩阵中的各列以及各行以规定的次数反复执行运算列处理用LLR的行处理的行处理部(22)；对于检验矩阵的各列以及各行运算行处理用LLR，进而，以规定的次数反复执行把行权重大小的行处理用LLR的绝对值的最小k值保持在中间结果保持部(21)中的列处理的列处理部(23)，行处理部(22)和列处理部(23)以列为单位交互地进行处理，在列处理部(23)循环地更新各行的最小k个值的同时，行处理部(22)使用近似的最小值进行运算。

Description

通信装置以及解码方法

技术领域

本发明涉及数字通信中的纠错技术，特别是涉及对被LDPC(低密度奇偶检验)编码过的信号进行解码的接收一侧的通信装置及其解码方法。

背景技术

作为解码LDPC码的基本算法有「Sum-Product算法」和「Min-Sum算法」，这些方法通过在计算作为接收信号的随机的可靠性信息的对数似然比(LLR：对数似然比)的同时进行反复运算，从而进行解码处理(参照非专利文献1)。上述「Sum-Product算法」虽然解码性能高，但是由于要求使用有数学函数的运算，因此产生保持表的需求等对于实装计算成本高。另外，需要至少存储中间值为包含在“0”，“1”的二维校验矩阵中的“1”的数量大小的存储器。另一方面，「Min-Sum算法」虽然不需要数学函数，从而计算成本变低，但是解码性能差。

这里，说明上述「Sum-Product算法」。首先，在发射机一侧，使用M行×N列的奇偶检验矩阵H把发送数据进行LDPC编码，生成码字c＝(c₁，c₂，......，c_N)，c_n＝0，1(n＝1，2，......，N)。而且，对于该码字c，例如执行BPSK(二进制相移键控)调制等调制处理，发送调制信号x＝(x₁，x₂，......，x_N)。

另一方面，在接收机一侧，经由加性白色高斯信道(加性高斯白噪声信道：AWGN信道)，接收如以下的(1)式那样表示的信号y＝(y₁，y₂，......y_N)。

Y_n＝x_n+e_n    ......(1)

另外，e_n是平均为0，方差值σ²＝N₀/2的高斯噪声系列。

而且，在接收机一侧，对于经过上述信道接受得到的调制信号，进行与上述BPSK调制相对应的数字解调，进而，对于从解调结果得到的对数似然比(LLR)，实施基于「Sum-Product算法」的反复解码，最终输出硬判定结果。

接着，以下表示在上述接收机中实施的现有解码方法「Sum-Product算法」。

(初始化步骤)

首先，设定反复次数l＝1以及最大反复次数l_max，进而，如下述(2)式表示的那样输入接收LLR：λ_n作为在初始化时的从位节点到检查节点的LLR：β_mn ^(l＝1)。

β_mn ^(l)＝λ_n

n＝1，2，......，N

m＝1，2，......，M    ......(2)

(行处理步骤)

接着，作为行处理，对于各m、n，根据下述(3)式更新从检查节点m向位节点n发送的位n的第l次反复的LLR：α_mn ^(l)

${\mathrm{\α}}_{\mathrm{mn}}^{\left(l\right)}={2\tanh }^{-1}\left(\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\tanh \left(\frac{{\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}}{2}\right)\right)\·\·\·\left(3\right)$

式中，N(m)表示第m行的具有“1”的列号码的集合，n’表示n以外的N(m)，β_mn’ ^(l-1)表示从第n列以外的第(l-1)次的位节点向检查节点的LLR。

(列处理步骤)

接着，作为列处理，对于各m、n、根据下述(4)式更新从位节点n向检查节点m发送的位n的第l次反复的LLR：β_mn ^(l)。

${\mathrm{\β}}_{\mathrm{mn}}^{\left(l\right)}={\mathrm{\λ}}_n+\underset{m^{,}\∈M\left(n\right)\backslash m}{\mathrm{\Σ}}{\mathrm{\α}}_{m^{,}n}^{\left(l\right)}\·\·\·\left(4\right)$

另外，对于各个n，根据下述(5)式更新用于硬判定的位n的第1次反复的后验值β_n ^(l)。

${\mathrm{\β}}_n^{\left(l\right)}={\mathrm{\λ}}_n+\underset{m^{,}\∈M\left(n\right)}{\mathrm{\Σ}}{\mathrm{\α}}_n^{\left(l\right)}\·\·\·\left(5\right)$

式中，M(n)表示第n列的具有“1 ”的行号码的集合，m’表示m以外的M(n)，α_m’n ^(l)表示从第m行以外的第l次检查节点向位节点的LLR。

(停止规范)

然后，例如，在位n的第l次反复的后验值β_n ^(l)为「β_n ^(l)＞0」的情况下，解码结果作为「x_n’＝1」(x’与原始的发送信号x相对应)，另一方面，在「β_n ^(l)≤0」的情况下，解码结果作为「x_n’＝0」，得到解码结果x’＝(x₁’，......x_N’)。

而且，在奇偶检验的结果是「Hx’＝0」或者反复次数是「l＝l_max」的情况下(满足任一个条件的情况下)，输出这时的解码结果x’。另外，在上述两个条件的任一个都不满足的情况下，令「l＝l+1」，返回到上述行处理，以后顺序进行运算。

非专利文献1：低密度奇偶检验码及其解码方法LDPC(低密度奇偶检验)码/sum-product解码方法，和田山正著，Torikepps(トリケツプ)

发明内容

然而，虽然明确了上述「Sum-Product算法」解码性能高，但是另一方面，由于要求使用有数学函数的反复运算(tanh^-1的运算)，因此存在即使用硬件或软件任意一方来实现，接收机一侧的计算负荷都升高的问题。另外，虽然有为了降低计算负荷保持预定的表的方法(表查找)，但是存在为了保持该表所需要的存储量增大的问题。

另外，在上述「Sum-Product算法」中，需要用于至少存储中间值(每行的对数似然比，每次反复的更新值等)为包含在“0”、“1”的二维检验矩阵中的“1(权重)”的数量大小的存储器。即，存在存储器的消耗量非常大的问题。另外，在「Sum-Product算法」中，还有量化位数多，反复次数多等问题。

本发明是鉴于上述情况而完成的，目的在于在被LDPC编码过的码字的解码处理中，得到能减少计算量以及存储量的通信装置以及解码方法。另外，其目的在于得到实现缩小量化尺寸，进而减少反复次数的通信装置以及解码方法。

为了解决上述的课题，达到目的，本发明的通信装置使用检验矩阵把被LDPC编码过的码字进行解码，其特征在于，具备：保持通过解码算法中的规定处理得到的中间值的保持单元；根据与检验矩阵中的行权重相对应的对数似然比(从位节点向检查节点发送的对数似然比：称为行处理用LLR)的绝对值，执行运算在列处理中使用的对数似然比(从检查节点向位节点发送的对数似然比：称为列处理用LLR)的行处理的行处理单元；执行使用与列权重相对应的列处理用LLR，运算在行处理中使用的行处理用LLR，进一步把行处理用LLR的绝对值的最小k个值保持在上述保持单元中的列处理的列处理单元，上述列处理单元在更新行的上述最小k个值的同时进行解码。

依据本发明，在LDPC解码中，由于把用于行处理的LLR的绝对值通过循环构造以行为单位缩小为最小k个值，因此能起到大幅度减少用于保持这些值的存储量这样的效果。另外，依据本发明，由于与现有的「Min-Sum算法」相比较能有效地进行概率传播，因此能大幅度减少解码的反复次数，从而起到能大幅度减少解码处理中的计算量这样的效果。

附图说明

图1表示包括LDPC编码器以及LDPC解码器的通信系统的结构例子。

图2表示在LDPC解码器中，执行「Min-Sum算法」的行处理步骤时的行处理部的结构例子。

图3表示在LDPC解码器中，执行「Min-Sum算法」的列处理步骤时的列处理部的结构例子。

图4是表示「Min-Sum算法」中的处理的流程的流程图。

图5-1是表示实施方式1的LDPC解码器的结构例子的图。

图5-2是表示实施方式1的LDPC解码器的结构例子的图。

图6是表示在「循环近似min算法」中执行行处理的行处理部的结构例子的图。

图7-1是表示在「循环近似min算法」中执行列处理的列处理部的结构例子的图。

图7-2是表示在「循环近似min算法」中执行列处理的列处理部的结构例子的图。

图8是表示在n＝15的列处理中，在Min2LLR中保持n＝15的信息时的处理的图。

图9是表示「循环近似min算法」中的处理的流程的流程图。

图10是表示列号码标记的图。

图11是表示「循环近似min算法」与「Min-Sum算法」的比较仿真的结果的图。

图12是表示「循环近似min算法」与「Min-Sum算法」的比较仿真的结果的图。

图13是表示实施方式2的LDPC解码器的结构例子的图。

图14是表示关于反复次数的性能比较的图。

图15是表示实施方式3的执行行处理的行处理部的结构例子的图。

图16是表示实施方式4的执行行处理的行处理部的结构例子的图。

图17是表示对于「δmin算法」，应用「循环近似min算法」或者「Overlapped循环近似min算法」的解码算法与「Sum-Product算法」的比较结果的图。

图18是表示实施方式5的执行行处理的行处理部的结构例子的图。

图19是表示在实施方式6的「串行循环近似min算法」中，执行列处理的列处理部的结构例子的图。

符号的说明

1：LDPC编码器

2：调制器

3：信道

4：解码器

5：LDPC解码器

11：接收LLR计算部

12：解码芯部

21、21a：中间结果保持部

22、22-1、22-2、22-G：行处理部

23、23-1、23-2、23-G：列处理部

24：解码结果判定部

25、25a：控制部

31、31a、31b、31c：最小值选择部

32：符号运算部

33：LLR计算部

41：α加法部

42：λ加法部

43：最小k个值比较部

44：符号运算部

45：开关

具体实施方式

以下，根据附图详细说明本发明的通信装置以及解码方法的实施方式。另外，并不是由该实施方式限定本发明。另外，本发明的解码方法作为一个例子，在便携电话等无线通信中，能够应用于终端以及基站中的解码处理。另外，能够应用于卫星通信、HDD、光通信、无线LAN、量子密码以及其它的解码处理。

实施方式1

首先，说明用于实现本发明的通信装置以及解码方法的LDPC解码器的在通信系统内的定位。图1是表示包含LDPC编码器以及LDPC解码器的通信系统的结构例子的图。图1中，发射一侧的通信装置(称为发射装置)构成为包括LDPC编码器1和调制器2，接收一侧的通信装置(称为接收装置)构成为包括解调器4和LDPC解码器5。

这里，简单说明采用LDPC码的通信系统中的编码处理、解码处理的流程。在发射装置内的LDPC编码器1中，例如根据已知的方法，生成K行×N列的生成矩阵G(K：信息长度，N：码字长度)。而且，接受信息长度为K的消息(m₁，m₂，......，m_K)，使用该消息以及上述生成矩阵G，如下述的(6)式那样，生成码字C。其中，在把LDPC用的奇偶检验矩阵取为H(M行×N列)的情况下，生成矩阵G成为满足GH^T＝0(T是转置矩阵)，H(c₁，c₂，......，c_N)^T＝0的矩阵。

C＝(m₁，m₂，......，m_K)G

＝(c₁，c₂，......，c_N)    ......(6)

而且，在调制器2中，对于由LDPC编码器1生成的码字C，根据BPSK、多值PSK、多值QAM等预定的调制方式进行数字调制，经过信道3，把其调制信号x＝(x₁，x₂，......，x_N)发送到接收装置。

另一方面，在接收装置中，解调器4对于经过信道3接收到的调制信号y＝(y₁，y₂，......，y_N)，进行与上述BPSK、多值PSK、多值QAM等调制方式相对应的数字解调，进而，LDPC解码器5使用从解调结果得到的对数似然比(LLR)，实施后述的本实施方式的解码算法的反复解码，作为其解码结果输出硬判定值(与原来的消息m₁，m₂，......，m_K相对应)。

接着，在对于本实施方式的解码算法进行说明之前，说明作为前提的现有解码算法的「Min-Sum算法」。

在「Min-Sum算法」中，首先进行与上述的「Sum-Product算法」相同的初始化步骤，接着，执行该「Min-Sum算法」的行处理步骤，然后，通过执行与上述的「Sum-Product算法」相同的列处理步骤以及停止规范来进行概率信息的计算处理以及更新处理。以下，说明与「Sum-Product算法」的处理不同的「Min-Sum算法」的行处理步骤。

图2表示在LDPC解码器中执行「Min-Sum算法」的行处理步骤时的行处理部的结构例子。该行处理部由具备保持奇偶检验矩阵H的行权重大小的LLR：β_mn’ ^(l-1)的存储器部111和把各LLR进行大小比较输出LLR的最小值的比较器部112的最小值选择部101；具备保持上述行权重大小的LLR的符号的存储器部113和把各LLR的符号(+或者-)进行乘法运算的乘法器114的符号运算部102；通过把从最小值选择部101得到的最小值与从符号运算部102得到的符号的乘法结果(+或者-)相乘，计算LLR：α_mn ^(l)的LLR计算部103构成。

在上述行处理部中，最小值选择部101的比较部112具备多个2输入(a，b)的比较器，从上述存储器部111以及前一级比较器(第1级比较器仅是上述存储器部111)接收到比较对象的LLR的各比较器在「|a|＜|b|」的情况下输出|a|，在除此以外的情况下输出|b|，由此输出LLR的绝对值的最小值。而且，LLR计算部103把上述最小值与上述符号的乘法结果相乘，向列处理部转移作为其乘法结果的LLR：α_mn ^(l)。

另外，图3表示在LDPC解码器中执行「Min-Sum算法」的列处理步骤时的列处理部的结构例子。在该列处理部中，保持奇偶检验矩阵H的列权重的LLR：α_m’n ^(l)，通过把各LLR相加，输出第1次反复的后验值β_n ^(l)。

(行处理步骤)

另外，如果把上述「Min-Sum算法」的行处理一般化，则能够如下述(7)式那样表示。这里，作为行处理对于各个m、n，根据下述(7)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α_mn ^(l)。

${\mathrm{\α}}_{\mathrm{mn}}^{\left(l\right)}={2\tanh }^{-1}\left(\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\tanh \left(\frac{{\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}}{2}\right)\right)$

$={2\tanh }^{-1}(\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\mathrm{sgn}\left({\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\·\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\tanh \left(\frac{\left|{\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right))\·\·\·\left(7\right)$

$=\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\mathrm{sgn}\left({\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\·{2\tanh }^{-1}\left(\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\tanh \left(\frac{\left|{\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right)\right)$

$\≈\underset{n^{,}\∈N\left(m\right)\backslash n}{\mathrm{\Π}}\mathrm{sgn}\left({\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\·\underset{n^{,}\∈N\left(m\right)\backslash n}{\min }\left|{\mathrm{\β}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|$

式中，min|β_mn’ ^(l-1)|表示在奇偶检验矩阵H的第m行中除去第n列的LLR：β_mn’ ^(l-1)的绝对值的最小值，sgn(β_mn’ ^(l-1))表示除去第n列的LLR：β_mn’ ^(l-1)的符号。

如上所述，在执行了行处理步骤以后，在「Min-Sum算法」中，进而执行基于与上述的「Sum-Product算法」相同的列处理以及停止规范的处理，得到最终的符号结果。

接着，使用图4的流程图简单说明上述「Min-Sum算法」中的处理的流程。

在上述「Min-Sum算法」中，首先，根据接收信息计算接收LLR(步骤S1，S2)，把其结果作为初始值设定在存储器111中，进而，把反复次数初始化为l＝1(步骤S3)。接着，作为反复处理(步骤S4：第1次反复解码到最末次反复解码)，首先，进行第1次反复的解码运算中的行处理(行处理)，接着，进行第1次反复解码运算中的列处理(列处理)，然后，硬判定在第1次反复中计算出的后验值，把其判定值决定为解码结果，进而进行奇偶检验(停止规范)。而且，在上述停止规范中，在奇偶检验结果成为OK，或者反复次数成为l＝l_max的情况下，最终输出这时的解码结果(步骤S5)。

这样，在上述「Min-Sum算法」中，通过近似上述的「Sum-Product算法」的行处理，即近似(3)式，与「Sum-Product算法」相比较减少计算量以及存储量。然而，在上述「Min-Sum算法」中为了保持中间值，因此需要与包含在奇偶检验矩阵H中的“1(权重)”的数量相对应的巨大的存储量，为了进一步减少存储量，需要进一步的改良。

以下说明的本实施方式的解码算法是实现进一步减少上述的存储量和计算量的方法，例如，是改良了作为「Sum-Product算法」的近似解码方法的「Min-Sum算法」的算法。

接着，根据附图，详细说明构成本发明的接收装置的LDPC解码器5的结构以及基于LDPC解码器5的解码方法(解码算法)。

图5-1是表示本实施方式的LDPC解码器5的结构，该LDPC解码器5由根据接收信息计算接收LLR的接收LLR计算部11和进行本实施方式的解码处理的解码芯部12构成。另外，解码芯部12具备由用于预先保持解码的中间结果(中间值)的存储器构成的中间结果保持部21、执行本实施方式的行处理的行处理部22、执行本实施方式的列处理的列处理部23、作为本实施方式的停止规范，进行列处理中的后验值的硬判定以及奇偶检验结果的正误判定的解码结果判定部24、进行解码的反复控制的控制部25。

另外，本实施方式的解码算法是循环地更新最小k个值的LLR的绝对值的方法，是使用近似的最小值而不是使用正确的最小值来进行解码的方法，因此以后称为「循环近似min算法」。另外，所谓上述最小k个值表示「从最小值按照升序到第k个为止」。

这里，以下表示在上述接收装置中实施的「循环近似min算法」。

(初始化步骤)

首先，设定反复次数l＝1以及最大反复次数l_max。进而，把初始时的第m行的最小k个值的LLR作为β_mn(i) ⁽⁰⁾，输入接收LLR：λ_n，如下述(8)式表示的那样求B_mn(i)。另外，作为初始值的第m行的LLR：β_mn ⁽⁰⁾的符号，输入sgn(λ_n)，如下述(8)式表示的那样，求S_m。

$B_{\mathrm{mn}\left(i\right)}=\left|{\mathrm{\β}}_{\mathrm{mn}\left(i\right)}^{\left(0\right)}\right|=\underset{n\∈N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\λ}}_n\left|\right],\∀i\∈[1,k]$

$S_m=\underset{n\∈N\left(m\right)}{\mathrm{\Π}}\mathrm{sgn}\left({\mathrm{\λ}}_n\right)\·\·\·\left(8\right)$

$n\left(i\right)=\arg \underset{n\∈N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\λ}}_n\left|\right]$

n(0)＝φ

式中，B_mn(i)是第m行的最小k个值的LLR：β_mn(i)的绝对值，n(i)是B_mn(i)中的第i个最小的LLR的列号码，S_m是第m行的LLR：β_mn的符号(+或者-)的积。

(行处理步骤)

接着，作为行处理，对于1≤n≤N以及各个m，根据下述(9)式更新从检查节点m向位节点n传送的位n的第1次反复的LLR：α_mn ^(l)。另外，在本实施方式中，行处理的开始列为任意，在至最末列结束了处理的阶段，再次从最初的列开始循环进行解码处理。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(9\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$S_m^{\&prime;}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)$

具体地讲，在当前的列号码是n的情况下，对于满足「n’＜n」的列号码，取在第l次的列处理中被更新了的LLR：β_mn’ ^(l)的符号的积，另外，对于满足「n’＞n」的列号码，取在第(l-1)次的列处理中被更新了的LLR：β_mn’ ^(l-1)的符号的积，而且，把这些结果与第m行的最小k个值中的最小的LLR：min「β_mn’」的乘法结果作为列号码n的更新后的LLR：α_mn ^(l)。另外，在本实施方式中，进而，把上述β_mn’ ^(l)的符号的积与上述β_mn’ ^(l-1)的符号的积相乘的项替换为在第(l-1)次中被更新了的S_m与在第(l-1)次中被更新了的β_mn’的符号相乘的项。由此，能进一步减少计算量以及存储量。另外，上述(9)式的N_k(m)是第m行的n(i)的集合，表现为N_k(m)＝{n(1)，n(2)，......，n(k)}。

(列处理步骤)

接着，作为列处理，对于各个m、n，根据下述(10)式更新从位节点n向检查节点m传送的位n的第l次反复的LLR：β_mn ^(l)。

${\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)\backslash m}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_{m^{,}n}^{\left(l\right)}$

$S_m=S_m^{\&prime;}\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)$

$n\left(i\right)=\arg \underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1),n\left(i\right)\}}{\min }[B_{{\mathrm{mn}}^{,}},|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(10\right)$

$B_{{\mathrm{mn}}_{\left(i\right)}}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1),n\left(i\right)\}}{\min }[B_{{\mathrm{mn}}^{,}},|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right],\&ForAll;i\&Element;[1,k]$

具体地讲，在列号码n中，把接收LLR：λn与在第l次行处理中被更新了的第m行以外的LLR：α_m’n ^(l)的合计值的相加结果作为更新后的LLR：β_mn ^(l)。另外，通过把上述S_m’与在第l次列处理中被更新了的β_mn ^(l)的符号(+或者-)相乘，更新在行处理中使用的S_m。另外，上述(10)式中的下面的两个公式规定了B_mn(l)的重新排列处理(最小k个值)。

另外，关于各n，根据下述(11)式更新用于硬判定的位n的第l次反复的后验值β_n ^(l)。

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_n^{\left(l\right)}\&CenterDot;\&CenterDot;\&CenterDot;\left(11\right)$

(停止规范)

其后，例如在位n的第l次反复的后验值β_n ^(l)是「β_n ^(l)＞0」的情况下，把解码结果作为「x_n’＝1」(x’与原始的发送信号x相对应)，另一方面，在「β_n ^(l)≤0」的情况下，把解码结果设为「x_n’＝0」，得到解码结果x’＝(x₁’，x₂’，......，x_N’)。

而且，在奇偶检验的结果是「Hx’＝0」或者反复次数是「l＝l_max」的情况下(满足任一个条件的情况下)，输出这时的解码结果x’。另外，在上述两个条件的每一个都不满足的情况下，使「l＝l+1」，返回到上述行处理，以后按顺序执行运算。

接着，使用结构图具体说明执行上述「循环近似min算法」的LDPC解码器5的特征性的动作。

图6表示在上述「循环近似min算法」中执行行处理的行处理部22的结构例子，该行处理部22由最小值选择部31、符号运算部32和LLR计算部33构成。另外，图示的Min1LLR(第m行中的最小的LLR)是B_mn(1)，Min2LLR(第m行中的第2个最小的LLR)是B_mn(2)，是分别保持在中间结果保持部21中的值。另外，关于图示的S_m以及「第(l-1)次的第m行第n列的LLR：β_mn的符号」，也是分别保持在中间结果保持部21中的值。

在最小值选择部31中，在成为行处理的对象的列号码n与Min1LLR(B_mn(l))的列号码n(1)一致的情况下，选择Min2LLR(B_mn(2))，在除此以外的情况下，选择Min1LLR(B_mn(l))并输出。另外，符号运算部32把在「第(l-1)次的列处理中被更新了的S_m」以及「第(l-1)次的第m行n列的LLR：β_mn的符号」相乘，作为其结果输出S_m’。这时，S_m’保持在中间结果保持部21中。另外，LLR计算部33通过把从最小值选择部31得到的最小的LLR与从符号运算部32得到的符号的乘法结果S_m’(+或者-)相乘，计算LLR：α_mn ^(l)。根据该结构，能够把在「Min-Sum算法」中行权重大小所需要的存储器缩小为k个值大小。

图7-1表示在上述「循环近似min算法」中执行列处理的列处理部23的结构例子。该列处理部23由α加法部41、λ加法部42、最小k个值比较部43和符号运算部44构成。另外，在本实施方式中，作为一个例子记载了k＝3的情况。另外，图示的列权重大小的LLR、α_mn、λ_n、S_m’、Min1LLR、Min2LLR、Min3LLR(第m行中第3个最小的LLR)是分别保持在中间结果保持部21中的值。

在上述列处理部23中，α加法部41把在第l次行处理中被更新了的第m行以外的全部LLR：α_m’n ^(l)相加，进而，λ加法部42在α加法部41的加法结果上加上接收LLR：λ_n，输出β_mn ^(l)。而且，最小k个值比较部43(k＝3)接收|β_mn ^(l)|。这里，在图7-1中虽然没有图示，然而例如在成为列处理的对象的第n列的n与表示对应于Min1LLR、Min2LLR、Min3LLR中分别保持的B_mn(l)、B_mn(2)、B_mn(3)的列号码的n(1)、n(2)、n(3)的某一个一致的情况下，间拔成为n＝n(i)的B_mn(i)，进行图8所示的操作。具体地讲，删除保持在Min2LLR中的信息，把保持在Min3LLR中的信息移动到Min2LLR中，进而，在Min3LLR中例如(16比特的情况下)保存最大值“FFFF”。由此，能够进行去除了处理对象的列的比较处理，并且在列处理中至少必须更新Min3LLR。在该处理以后，如图7-1所示，把|β_mn ^(l)|与Min1LLR、Min2LLR、Min3LLR分别进行比较，如果是「|β_mn ^(l)|＜Min3LLR」则更新最小3值的LLR。另一方面，把λ加法部42输出的β_mn ^(l)的符号设为「第l次的第m行n列的LLR：β_mn ^(l)的符号」，保持在中间结果保持部21中，进而，符号运算部44把在第l次行处理中被更新了S_m’与上述β_mn ^(l)的符号相乘，使用其结果，更新保持在中间结果保持部21中的S_m。另外，在|β_mn ^(l)|与Min1LLR、Min2LLR、Min3LLR的比较时，最初把|β_mn ^(l)|与作为B_mn(i)的中心值的Min2LLR进行比较，以后，如图所示，虽然树形地进行比较，但例如与从作为最小值的Min1LLR开始进行比较的情况相比，具有执行时间成为{(k+1)/2}/k(k是奇数的情况)的效果。另外，在k是偶数的情况下，B_mn(i)的中心值成为2个，而最初开始比较的对象可以是任一个。在k是偶数的情况下，与从作为最小值的Min1LLR开始进行比较的情况相比，具有执行时间成为{k/2+1}/k(k是偶数的情况)的效果。

另外，也能够用图7-2表示的结构实现与上述相同的处理，这时，在α加法部41中，仅进行列权重大小的所有LLR的加法运算，然后，在λ加法部42中进行λ_n的加法运算，把其结果输出到解码结果判定部24，并且进行作为第m行的LLR的α_mn的减法运算。即使是这样的顺序也能够得到与上述处理的顺序相同的结果。这时的LDPC解码器的结构为图5-2所示那样。

接着，使用图9的流程图说明本实施方式的「循环近似min算法」中的处理流程。

在上述「循环近似min算法」中，首先，接收LLR计算部11根据接收信息计算接收LLR(步骤S11，S12)，把其结果作为初始值设定在中间结果保持部21中(步骤S13)，进而，控制部25把反复次数初始化为l＝1(步骤S13)。另外，在列处理部23中，使用λ加法部42、最小k个值比较部43、符号运算部44，从n＝1到n＝N循环地进行上述(8)式的运算(步骤S13)。

接着，解码芯部12通过控制部25的控制，进行第l次(第1次～最末次)的反复解码运算(步骤S14)。具体地讲，作为反复解码的第1次，行处理部22对在第1列中具有“1”的行进行行处理(使用接收LLR)，把其结果转移到列处理部23。然后，列处理部23进行第1列的列处理，把作为其结果的B_mn(i)和S_m保持在中间结果保持部21中(更新)。以后，按照第2列，第3列，......，第n列的顺序，进行与上述相同的处理，分别把B_mn(i)和S_m保持在中间结果保持部21中(相当于第1次反复解码)。然后，在反复解码的第2次以后，使用在前一个处理中被更新了的LLR以及S_m进行行处理，除此以外，与上述第1次相同地进行解码处理。

另外，在实施了上述第1次反复解码以后，解码结果判定部24硬判定在第1次反复中计算出的后验值，把其判定值决定为解码结果x’，进而进行奇偶检验(停止规范)。而且，在该停止规范中，在奇偶检验结果成为OK(「Hx’＝0」)或者反复次数成为l＝l_max的情况下，最终输出这时的解码结果x’(步骤S15)。另外，在不满足上述两个条件的情况下，控制部25使l＝l+1，在解码芯部12中，执行第(l+1)次的反复解码。

接着，说明基于列号码的标记方法的存储器尺寸的减少。图10是表示本实施方式列号码标记的图。在「循环近似min算法」中，例如从n＝0开始按照升序标记列号码。另外，当前用奇偶检验矩阵的列号码自身(绝对列号码)表现列号码n，而在本实施方式中，把奇偶检验矩阵中的第m行的“1”的最小列号码作为n＝0，把第m行的下一个“1”的列号码作为n＝1，以后，在每一个“1”用作为n＝2，3，......的相对的列号码表现。即，以往在奇偶检验矩阵的“1”的绝对列号码例如是“32768”的情况下，为了表现列号码所需要的位数为15位，而另一方面，在本实施方式中，例如如果行权重是8个，则把存储器尺寸缩小到能表现0～7的3位，如果行权重是16个，则把存储器尺寸缩小到能表现0～15的4位。

如上所述，在本实施方式中，在LDPC解码中，由于通过循环构造以行为单位把用于行处理的LLR的绝对值|β_mn|缩小为最小k个值，因此能大幅度减少用于保持这些值的存储量。例如，在行权重是20，k＝3的情况下，与以往相比较，能够把存储量减少到3/20。另外，通过把列号码从绝对列号码(1，3，10，15，......)变更成相对的列号码(0，1，2，3，......)，能进一步减少存储量。

另外，在本实施方式的「循环近似min算法」中，按照1位1位地循环进行行处理和列处理的概率信息(LLR)的计算以及更新。由此，与现有的「Min-Sum算法」相比，能有效地进行概率传播。

例如，图11，图12中表示「循环近似min算法」与「Min-Sum算法」的比较仿真的结果。LDPC码是非规则EG代码，最大行权重是8。图11中表示把解码反复次数固定为100次，把「循环近似min算法」保存的最小值的个数改变成3、4、5个，与「Min-Sum算法」进行了性能比较的情况。图中，CyclicXmin表示保持了最小X个值的「循环近似min算法」，Min-Sum表示「Min-Sum算法」。如从图11所明确的那样，根据本实施方式的「循环近似min算法」，能够确认在减少存储器的同时解码性能并没有恶化。

另外，图12中表示在「循环近似min算法」和「Min-Sum算法」中，把至解码成功所需要的平均反复次数进行了比较的结果。图中，CyclicXmin表示保存了最小X个值的「循环近似min算法」，Min-Sum表示「Min-Sum算法」。从其结果也可以知道，在「循环近似min算法」中有效地进行概率传播，大幅度减少解码反复次数。即，根据本实施方式的「循环近似min算法」，能大幅度降低解码处理中的计算量。

另外，在本实施方式中，行处理的运算对象的LLR是单个值，而k的个数可以是2个值以上的任意值。另外，在本实施方式中，说明交互地各进行一次行处理和列处理，与此相对应，按1位1位地循环进行基于行处理和列处理的概率信息(LLR)的更新的情况，但并不限于这种情况，也可以在执行了多次行处理以后，执行多次列处理。即，可以按照每多个位多个位地循环进行行处理和列处理的概率信息(LLR)的计算以及更新。

实施方式2

接着，说明实施方式2的接收装置以及解码方法。本实施方式的LDPC解码能应用于按照1位1位或者预先确定的多位多位地进行基于行处理和列处理的概率信息(LLR)的计算以及更新的情况，例如，通过使运算处理并行，谋求减少反复次数。另外，在本实施方式中，与并行的数量无关，使中间结果保持部的B_mn(i)以及S_m为一组，执行并行了的全部处理部更新同一个B_mn ^C以及S_m的使用了所谓「Overlapped(交迭)」了的B_mn ^C以及S_m的「Overlapped(交迭)循环近似min算法」。以后，把本实施方式的解码算法称为「Overlapped(交迭)循环近似min算法」。

这里，以下表示在本实施方式的接收装置中实施的「Overlapped(交迭)循环近似min算法」。

(初始化步骤)

首先，设定反复次数l＝1以及最大反复次数l_max。进而，把初始时的第m行的最小k个值的LLR取为β_mn(i) ⁽⁰⁾，输入接收LLR：λ_n，如下述(12)式表示的那样求B_mn(i) ^C。另外，作为初始时的第m行的LLR：β_mn(i) ⁽⁰⁾的符号，输入sgn(λ_n)，如下述(12)式那样求S_m。

$B_{{\mathrm{mn}}^{,}}^C=\left|{\mathrm{\&beta;}}_{\mathrm{mn}\left(i\right)}^{\left(0\right)}\right|=\underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right],\&ForAll;i\&Element;[1,k]$

$S_m=\underset{n\&Element;N\left(m\right)}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&lambda;}}_n\right)\&CenterDot;\&CenterDot;\&CenterDot;\left(12\right)$

$n\left(i\right)=\arg \underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right]$

n(0)＝φ

式中，B_mn(i) ^C是第m行的最小k个值的LLR：β_mn(i)的绝对值，在并行处理时共同使用。另外，n(i)是在B_mn(i) ^C中第i个最小的LLR的列号码。

(行处理步骤)

接着，作为行处理，对于0≤g≤G-1，g·G+1≤n≤(g+1)·N_G以及各个m，根据下述(13)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α_mn ^(l)。另外，G是并行数，N_G是并行了的各解码电路处理的列数。另外，G·N_g＝N。另外，在本实施方式中，各行处理的开始列为任意，在至最末列结束了处理的阶段，再次从最初的列开始循环进行解码处理。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(13\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}^C\right]$

$S_m^{\&prime;}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)$

具体地讲，例如，针对每个列数：N_G分割为G个的各列区中分别分配的G个行处理部并行执行行处理。另外，G个行处理部并行地进行处理，所有的处理部除去使用相同的B_mn ^C以外，与上述的「循环近似min算法」同样进行动作。

(列处理步骤)

接着，作为列处理，对于0≤g≤G-1，g·G+1≤n≤(g+1)·N_G以及各个m，根据下述(14)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：β_mn ^(l)。另外，在本实施方式中，对于如上所述并行进行了行处理以后的各列，并行执行下述(14)式表示的列处理。

${\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)\backslash m}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_{m^{,}n}^{\left(l\right)}$

$S_m=S_m^{\&prime;}\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)$

$n\left(i\right)=\arg \underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1),n\left(i\right)\}}{\min }[B_{{\mathrm{mn}}^{,}}^C,|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(14\right)$

$B_{\mathrm{mn}\left(i\right)}^C=\underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1),n\left(i\right)\}}{\min }[B_{{\mathrm{mn}}^{,}}^C,|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right],\&ForAll;i\&Element;[1,k]$

另外，关于各个n，根据下述(15)式更新用于硬判定的位n的第l次反复的后验值β_n ^(l)。

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_n^{\left(l\right)}\&CenterDot;\&CenterDot;\&CenterDot;\left(15\right)$

另外，关于停止规范，与上述的「循环近似min算法」相同。

接着，说明用于实现上述「Overlapped循环近似min算法」的实施方式2的LDPC解码器5的结构以及动作。

图13是表示本实施方式的LDPC解码器5的结构例子的图，由根据接收信息计算接收LLR的接收LLR计算部11和进行本实施方式的解码处理的解码芯部12a构成。另外，解码芯部12a具备由用于保持解码的中间结果(中间值)的存储器构成的中间结果保持部21a；执行本实施方式的行处理(并行处理)的行处理部22-1～22-G；执行本实施方式的列处理(并行处理)的列处理部23-1～23-G；作为本实施方式的停止规范，进行列处理中的后验值的硬判定以及奇偶检验结果的正误判定的解码结果判定部24、进行解码的反复控制的控制部25a。

图13中，本实施方式的LDPC解码部5在各行处理部以及各列处理部并行进行处理时，根据上述(12)式、(13)式、(14)式，共同使用中间结果保持部21a的B_mn ^C以及S_m，分别进行更新。通过该并行处理，根据并行数迅速地变更B_mn ^C以及S_m,与此相伴随，能大幅度减少解码的反复次数。

另外，在本实施方式中，在并行处理中，当在同一块中发生了同一行的运算，产生了参照同一个缓冲器的问题的情况下，例如，进行在各处理部中设置存储器访问的优先顺序、划分存储体、使用移位寄存器调整存储器访问的定时等的对策。

如上所述，本实施方式的「Overlapped(交迭)循环近似min算法」应用上述的「循环近似min算法」，分别并行执行行处理以及列处理。另外，在并行执行的各列处理中共有保持被更新的最小k个值的中间结果保持部，在并行执行的各列处理中，分别更新最小k个值。由此，与「Min-Sum算法」以及上述的实施方式1相比较，能大幅度减少解码器反复次数。

图14表示关于反复次数的性能比较。详细地讲，是关于并行数为2时的「Overlapped循环近似min算法」、「循环近似min算法」、「Min-Sum算法」，在固定了解码的反复次数的状态下，比较了各个解码性能的结果。图14中，在把解码的反复次数限制为很少的情况下，「循环近似min算法」与以往的「Min-Sum算法」相比较，能够确认解码性能高，进而，能够确认「Overlapped循环近似min算法」在「循环近似min算法」的一半的解码反复次数下具有同等程度的解码性能。另外，图14中，由于把并行数取为2，因此解码的反复次数是一半左右，而在使用了「Overlapped循环近似min算法」的情况下，反复次数成为「循环近似min算法」的「1/并行数」。

实施方式3

接着，说明实施方式3的接收装置以及解码方法。在本实施方式中，对于作为应用了「Min-Sum算法」的已知的解码算法的「Normalized(标准化)BP-based算法」，应用实施方式1的「循环近似min算法」或者实施方式2的「Overlapped循环近似min算法」中的仅循环地更新最小k个值的LLR的绝对值的处理以及使用了近似最小值的解码处理。

这里，在对本实施方式的解码算法进行说明之前，以下表示成为其前提的已知的「Normalized(标准化)  BP-based算法」。另外，这里，对于与「Min-Sum算法」的处理不同的行处理进行说明。

(行处理步骤)

例如，如果把「Normalized BP-based算法」的行处理一般化，则能够如下述(16)式那样表示。这里，作为行处理，对于各个m、n，根据下述(16)式更新第1次反复的LLR：α_mn ^(l)。另外，式中的A是称为标准化因子的常数，在「Normalized BP-based算法」中，根据标准化因子A修正根据「Min-Sum算法」得到的第l次反复的LLR。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}={2\tanh }^{-1}\left(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}}{2}\right)\right)$

$={2\tanh }^{-1}(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right))\&CenterDot;\&CenterDot;\&CenterDot;\left(16\right)$

$=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;{2\tanh }^{-1}\left(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right)\right)$

$\&ap;\frac{1}{A}\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\min }\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|$

接着，以下表示对于上述「Normalized BP-based算法」，应用了「循环近似min算法」或者「Overlapped循环近似min算法」时的解码算法。另外，在本实施方式中，关于与上述的「循环近似min算法」或者「Overlapped循环近似min算法」相同的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述的「循环近似min算法」或者「Overlapped循环近似min算法」的处理不同的行处理。

(应用了循环近似min算法时的行处理步骤)

例如，如果把应用了「循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(17)式那样表示。这里，作为行处理，对于各个m、n，根据下述(17)式更新第l次反复的LLR：α_mn ^(l)。即，在下述(17)式中，根据标准化因子A修正根据「循环近似min算法」得到的第l次反复的LLR。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环地进行解码处理。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\frac{1}{A}\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(17\right)$

$=\frac{1}{A}{S}_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

(应用了Overlapped循环近似min算法时的行处理步骤)

另外，如果把应用了「Overlapped循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(18)式那样表示。这里，作为行处理，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(18)式更新第l次反复的LLR：α_mn ^(l)。即，在下述(18)式中，根据标准化因子A修正根据「Overlapped循环近似min算法」得到的第l次反复的LLR。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\frac{1}{A}\underset{\underset{n^{,}<g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]$

$=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(18\right)$

$=\frac{1}{A}{S}_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]$

另外，本实施方式的解码算法中，在如上述那样执行了行处理步骤以后，进而，执行与上述的「循环近似min算法」或者「Overlapped循环近似min算法」同样的列处理以及基于停止规范的处理，得到最终的符号结果。

接着，使用附图说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部分的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或者图示13相同。

图15是表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子的图，该行处理部具备最小值选择部31a。另外，关于与上述的图6相同的结构标注相同的号码，并省略其说明。在本实施方式的最小值选择部31a中，例如，使用标准化因子A修正从中间结果保持部21(或者21a)读出的LLR的最小值(Min1LLR或者Min2LLR)。具体地讲，通过用A除LLR的最小值进行标准化。

如上所述，在本实施方式中，在性能比「Min-Sum算法」良好的「Normalized BP-based算法」中应用「循环近似min算法」或者「Overlapped循环近似min算法」。由此，可以得到与上述的实施方式1、2相同的效果，同时，进而尽管是几乎与「Min-Sum算法」同等的电路量，但仍然能够实现接近「Sum-Product算法」的性能。

另外，在本实施方式中，在「Normalized BP-based算法」中应用「循环近似min算法」或者「Overlapped循环近似min算法」，但并不限于这种方法，也能够在已知的「Offset BP-based算法」或者除此以外的算法中应用「循环近似min算法」或者「Overlapped循环近似min算法」，在该情况下，也能得到与上述同样的效果。

实施方式4

接着，说明实施方式4的接收装置以及解码方法。在本实施方式中，对于作为LLR：β_mn的修正性能比「Normalized BP-based算法」或者「Offset BP-based算法」出色的已知的解码算法的「δmin算法」，应用实施方式1的「循环近似min算法」或者实施方式2的「Overlapped循环近似min算法」中的仅循环地更新最小k个值的LLR的绝对值的处理以及使用了近似的最小值的解码处理。

这里，在对于本实施方式的解码算法进行说明之前，以下表示成为其前提的已知的「δmin算法」。另外，这里说明与「Min-Sum算法」的处理不同的行处理。

(行处理步骤)

例如，如果把「δmin算法」的行处理一般化，则能够如下述(19)式那样表示。这里，作为行处理，对于各个m、n，根据下述(19)式更新第l次反复的LLR：α_mn ^(l)。在「δmin算法」的行处理中，根据在第l-1次反复中更新了的LLR的绝对值：|β_mn’ ^(i-1)|，通过Θ的运算计算α_mn ^(l)。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[\right|{\mathrm{\&beta;}}_{m,n^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{\&Theta;}}\left(I_n\right)\&equiv;I_1\mathrm{\&Theta;}{I}_2\mathrm{\&Theta;}\&CenterDot;\&CenterDot;\&CenterDot;{\mathrm{\&Theta;I}}_{\left|A\right|}\&CenterDot;\&CenterDot;\&CenterDot;\left(19\right)$

aΘb≡max(min(a，b)-Δ，0)

Δ≡max(0.9-|a-b|/2，0)

接着，以下表示对于上述「δmin算法」，应用了「循环近似min算法」或者「Overlapped循环近似min算法」时的解码算法。另外，在本实施方式中，关于与上述的「循环近似min算法」或者「Overlapped循环近似min算法」同样的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述的「循环近似min算法」或者「Overlapped循环近似min算法」的处理不同的行处理。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环地进行解码处理。

(应用了循环近似min算法时的行处理步骤)

例如，如果把应用了「循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(20)式那样表示。这里，作为行处理，对于1≤n≤N以及各个m，根据下述(20)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法行处理中，根据在第l-1次反复中更新了的最小k个值的LLR的绝对值：B_mn’，通过Θ的运算计算α_mn ^(l)。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(20\right)$

$=S_m^{,}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

(应用了Overlapped循环近似min算法时的行处理步骤)

另外，如果把应用了「Overlapped循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(21)式那样表示。这里，作为行处理，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(21)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法行处理中，根据在第l-1次反复中以并行处理被更新了的最小k个值的LLR的绝对值：B_mn’ ^C，通过Θ的运算计算α_mn ^(l)。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(21\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

另外，在本实施方式的解码算法中，如上述那样执行了行处理步骤以后，进而，执行与上述的「循环近似min算法」或者「Overlapped循环近似min算法」同样的列处理以及基于停止规范的处理，得到最终的符号结果。

接着，使用附图说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或者图13相同。

图16是表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子的图，该行处理部具备最小值选择部31b。另外，关于与上述的图6相同的结构标注相同的号码，省略其说明。另外，这里作为一个例子，说明了图5的LDPC解码器5的情况，而关于图13的LDPC解码器5也同样适用。

在本实施方式的最小值选择部31b中，例如从中间结果保持部21读出Min1LLR(B_mn(1))、Min2LLR(B_mn(2))、Min3LLR(B_mn(3))和各个列号码，运算部进行Θ的运算。即，在本实施方式的最小值选择部31b中，对于成为处理对象的第n列与保持在中间结果保持部21中的B_mn(k)的列号码n(k)不一致的B_mn(k)，运算部进行「δmin算法」中的以下的运算。

例如，运算部如下述(22)式那样求除去符号的更新值|α_mn ^(l)|(＝Θ[B_mn’])。

$\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(22\right)$

另外，通过把运算对象的LLR从k个值限定为最小3个值能够减少运算量，运算部如下述(23)式那样求除去符号的更新值|α_mn ^(l)|(＝Θ[B_mn’])。

[数20]

如果 $(n=n_{\left(1\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(2\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(3\right)}}$

否则  如果 $(n=n_{\left(2\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(3\right)}}\&CenterDot;\&CenterDot;\&CenterDot;\left(23\right)$

否则 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(2\right)}}$

另外，在上述中，作为一个例子说明了把运算对象的LLR从k个值限定为最小3个值的情况，而在限定为最小4、5......个值的情况下也能够同样适用。

如上所述，在本实施方式中，在性能比「Min-Sum算法」良好的「δmin算法」中应用「循环近似min算法」或者「Overlapped循环近似min算法」。由此，可以得到与上述实施方式1、2同样的效果，并且进而尽管是几乎与「Min-Sum算法」同等的电路量，也能够实现接近「Sum-Product算法」的性能。另外，在本实施方式中，记载了根据在已知的「δmin算法」中规定的预定修正式把行处理用的LLR的绝对值的最小值修正为最佳值的情况，然而修正式并不限于该公式，也可以使用在「δmin算法」以外的算法中规定的修正式。这种情况下也能得到与上述相同的效果。

图17表示对于「δmin算法」，应用了「循环近似min算法」或者「Overlapped循环近似min算法」的解码算法与「Sum-Product算法」的比较结果。例如，overlap5delta10表示使用了「Overlapped循环近似min算法」的本实施方式的解码算法(并行数是2，最小5个值，l＝10)，Cyclic5delta 50表示使用了「循环近似min算法」的本实施方式的解码算法(没有并行，最小5个值l＝50)，Sum-Product100表示「Sum-Product算法」(l＝100)，几乎重叠。根据该结果，通过对于「δmin算法」应用「循环近似min算法」或者「Overlapped循环近似min算法」，不仅具有与「Sum-Product算法」同等程度的性能，还能大幅度减少解码的反复次数。

实施方式5

接着，说明实施方式5的接收装置以及解码方法。本实施方式中，对于「Sum-Product算法」，应用仅循环地更新实施方式1的「循环近似min算法」或者实施方式2的「Overlapped循环近似min算法」中的最小k个值的LLR的绝对值的处理以及使用了近似的最小值的解码处理。

这里，在对于本实施方式的解码算法进行说明之前，以下表示成为其前提的已知的「Sum-Product算法」。另外，在本实施方式中，记载对数学函数进行表处理来进行运算的方法，即，利用了TLU(表查找)的一般的「Sum-Product算法」。另外，这里，记载关于与在现有技术中说明过的「Sum-Product算法」的处理不同的行处理。

(行处理步骤(1))

例如，如果把利用了TLU的「Sum-Product算法」的行处理一般化，则能够如下述(24)那样表示。这里，作为行处理，对于各个m、n，根据下述(24)式更新第l次反复的LLR：α_mn ^(l)。在利用了TLU的「Sum-Product算法」的行处理中，对于在第l-1次更新了的LLR的绝对值：|β_mn’ ^(i-1)|，进行使用TLU的运算。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{TLU}}\left[\right|{\mathrm{\&beta;}}_{m,n^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{TLU}}\left(I_n\right)\&equiv;\mathrm{TLU}(I_1,\mathrm{TLU}(I_2,\&CenterDot;\&CenterDot;\&CenterDot;\mathrm{TLU}(I_{\left|A\right|-1},I_{\left|A\right|})))\&CenterDot;\&CenterDot;\&CenterDot;\left(24\right)$

$\mathrm{TLU}(a,b)\&equiv;{2\tanh }^{-1}(\tanh \frac{a}{2}\&CenterDot;\tanh \frac{b}{2})$

(行处理步骤(2))

另外，在与上述不同的方法中，也能够实现利用了TLU的「Sum-Product算法」的行处理。例如，如果把与上述不同的利用了TLU的「Sum-Product算法」的行处理一般化，则能够如下述(25)式那样表示。这里，作为行处理，对于各个m、n，根据下述(25)式更新第l次反复的LLR：α_mn ^(l)。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[\right|{\mathrm{\&beta;}}_{m,n^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{\&Xi;}}\left(I_n\right)\&equiv;I_1\mathrm{\&Xi;}{I}_2\mathrm{\&Theta;}\&CenterDot;\&CenterDot;\&CenterDot;\mathrm{\&Xi;}{I}_{\left|A\right|}\&CenterDot;\&CenterDot;\&CenterDot;\left(25\right)$

aΞb≡min(a，b)+TLU1(|a+b|)-TLU1(|a-b|)

另外，TLU1(x)根据下述(26)式预先准备表。

TLU1(x)＝ln(1+exp(-x))    ......(26)

另外，在利用了上述TLU的「Sum-Product算法」中，上述(24)式中表示的行处理具有虽然表变大但是运算次数少的特征，另一方面，上述(25)表示的行处理具有虽然表变小但是运算次数多的特征。

接着，以下表示对于上述利用了TLU的「Sum-Product算法」应用了「循环近似min算法」时的解码算法。另外，在本实施方式中，对于与上述的「循环近似min算法」同样的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述「循环近似min算法」处理不同的行处理。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环进行解码处理。

(应用了循环近似min算法时的行处理步骤(1))

例如，如果把对于上述行处理步骤(1)应用了「循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(27)式那样表示。这里，作为行处理，对于1≤n≤N以及各个m，根据下述(27)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理中，对于在第l-1次反复中更新了的最小k个值的LLR的绝对值：B_mn’，进行使用TLU的运算。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(27\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]$

(应用了循环近似min算法时的行处理步骤(2))

另外，如果把对于上述行处理步骤(2)应用了「循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(28)式那样表示。这里，作为行处理，对于1≤n≤N以及各个m，根据下述(28)式更新第l次反复的LLR：α_mn ^(l)。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(28\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

接着，以下表示对于上述利用了TLU的「Sum-Product算法」应用了「Overlapped循环近似min算法」时的解码算法。另外，在本实施方式中，对于与上述的「Overlapped循环近似min算法」相同的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述「Overlapped循环近似min算法」的处理不同的行处理。

(应用了「Overlapped循环近似min算法」时的行处理步骤(1))

例如，如果把对于上述行处理步骤(1)应用了「Overlapped循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(29)式那样表示。这里，作为行处理，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(29)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理中，对于在第l-1次反复中以并列处理更新了的最小k个值的LLR的绝对值：B_mn’ ^C，进行使用了TLU的运算。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(29\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

(应用了「Overlapped循环近似min算法」时的行处理步骤(2))

另外，如果把对于上述行处理步骤(2)应用了「Overlapped循环近似min算法」时的本实施方式的解码算法的行处理一般化，则能够如下述(30)式那样表示。这里，作为行处理，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(30)式更新第l次反复的LLR：α_mn ^(l)。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(30\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

接着，根据附图说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或图13相同。

图18是表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子的图，该行处理部具备最小值选择部31c。另外，关于与上述的图6相同的结构标注相同的号码，省略其说明。另外，这里作为一个例子，说明了图5的LDPC解码器5的情况，而关于图13的LDPC解码器5也同样适用。

在本实施方式的最小值选择部31 c中，例如从中间结果保持部21读出Min1LLR(B_mn(1))、Min2LLR(B_mn(2))、Min3LLR(B_mn(3))和各个列号码，运算部进行使用了TLU的运算。即，在本实施方式的最小值选择部31c中，对于成为处理对象的第n列与保持在中间结果保持部21中的B_mn(k)的列号码n(k)不一致的B_mn(k)，运算部进行「Sum-Product算法」中的以下的运算。

例如，运算部如下述(31)式那样求除去符号的更新值。

[数27]

$\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TUL}}\left[B_{{\mathrm{mn}}^{,}}\right]$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(31\right)$

另外，通过把运算对象的LLR从k个值限定为最小3个值能够减少运算量，运算部如下述(32)式那样求除去符号的更新值。

[数28]

如果 $(n=n_{\left(1\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}(B_{{\mathrm{mn}}_{\left(2\right)}},B_{{\mathrm{mn}}_{\left(3\right)}})$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(2\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(3\right)}}$

否则  如果 $(n=n_{\left(2\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}(B_{{\mathrm{mn}}_{\left(1\right)}},B_{{\mathrm{mn}}_{\left(3\right)}})$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(3\right)}}\&CenterDot;\&CenterDot;\&CenterDot;\left(32\right)$

否则 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}(B_{{\mathrm{mn}}_{\left(1\right)}},B_{{\mathrm{mn}}_{\left(2\right)}})$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(2\right)}}$

另外，上述中作为一个例子说明了把运算对象的LLR从k个值限定为最小3个值的情况，而即使在限定为最小4、53......个值的情况下也能够同样适用。

如以上那样，在本实施方式中，在利用了TLU的「Sum-Product算法」中应用了「循环近似min算法」或者「Overlapped循环近似min算法」。由此，与其它的实施方式相比较，虽然计算量以及存储量变多，但是能够使解码性能提高。另外，在本实施方式中，作为例子说明了应用TLU的「Sum-Product算法」，而在对于数学函数进行TLU的其它解码算法中也相同。另外，在本实施方式中，记载了对于行处理用的LLR的绝对值的最小值，使用了由已知的「Sum-Product算法」规定的TLU的情况，而TLU并不受此限制，也可以使用由「Sum-Product算法」规定了的TLU以外的TLU。这种情况下也能够得到与上述相同的效果。

实施方式6

接着，说明实施方式6的通信装置以及解码方法。本实施方式的解码处理通过与完全的位单位的串行解码相对应，进一步谋求降低反复次数。

与上述的实施方式相同，图5-1表示本实施方式的LDPC解码器5的结构，该LDPC解码器5由从接收信息计算接收LLR的接收LLR计算部11和进行本实施方式的解码处理的解码芯部12构成。另外，解码芯部12具备由用于保持解码的中间结果(中间值)的存储器构成的中间结果存储部21、执行本实施方式的行处理的行处理部22、执行本实施方式的列处理的列处理部23、作为本实施方式的停止规范，进行列处理中的后验值的硬判定以及奇偶检验结果的正误判定的解码结果判定部24、进行解码的反复控制的控制部25。

另外，本实施方式的解码算法是仅循环地更新最小k个值的LLR的绝对值的方法，是使用近似的最小值而不使用正确的最小值进行解码的方法，由于是串行解码法，因此以后称为「串行循环近似min算法」。另外，作为上述最小k个值表示「从最小值按照升序直到第k个」。

这里，以下表示在上述接收装置中实施的「串行循环近似min算法」。

(初始化步骤)

首先，设定反复次数l＝1以及最大反复次数l_max。进而，把初始时的第m行的最小k个值的LLR作为β_mn(i) ⁽⁰⁾，输入接收LLR：λ_n，如下述(33)式表示的那样求B_mn(i)。另外，作为初始时的第m行的LLR：β_mn ⁽⁰⁾的符号，输入sgn(λ_n)，如下述(33)式表示的那样求S_m。

$B_{\mathrm{mn}\left(i\right)}=\left|{\mathrm{\&beta;}}_{\mathrm{mn}\left(i\right)}^{\left(0\right)}\right|=\underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right],\&ForAll;i\&Element;[1,k]$

$S_m=\underset{n\&Element;N\left(m\right)}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&lambda;}}_n\right)\&CenterDot;\&CenterDot;\&CenterDot;\left(33\right)$

$n\left(i\right)=\arg \underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right]$

n(0)＝φ

式中，B_mn(i)是第m行的最小k个值的LLR：β_mn(i)的绝对值，n(i)是B_mn(i)中第i个最小的LLR的列号码，S_m是第m行的LLR：β_mn的符号(+或者-)的积。

(行处理步骤1)

接着，作为行处理，对于1≤n≤N以及各个m，根据下述(34)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α_mn ^(l)。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环地进行解码处理。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(34\right)$

$S_m^{\&prime;}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)$

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m\&Element;M\left(n\right)}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_{mn}^{\left(l\right)}$

具体地讲，在当前的列号码是n时，对于满足「n’＜n」的列号码，取在第l次列处理中被更新了的LLR：β_mn’ ^(l)的符号的积，另外，对于满足「n’＞n」的列号码，取在第(l-1)次列处理中被更新了的LLR：β_mn’ ^(l-1)的符号的积，而且，把它们的结果与第m行的最小k值中的最小的LLR：min[β_mn’]的乘法结果作为列号码n的更新后的LLR：α_mn ^(l)。另外，在本实施方式中，进而把上述β_mn’ ^(l)的符号的积与上述β_mn’ ^(l-1)的符号的积相乘的项替换为把在第(l-1)次中被更新了的S_m与在第(l-1)次中被更新了的β_mn’的符号相乘的项。由此，能够进一步减少计算量以及存储量。另外，上述(34)式的N_k(m)是第m行的n(i)的集合，表示为N_k(m)＝{n(1)，n(2)，......，n(k)}。

(列处理步骤)

接着，作为列处理步骤，对于在行处理步骤1中进行的列号码n的各个m，根据下述(35)式更新从位节点n向检查节点m传送的位n的第l次反复的LLR：β_mn ^(l)。其以后的列处理步骤以及行处理步骤2例如从行号码m的最小的行号码开始按顺序一行一行地执行计算。而所执行的行号码的顺序如果不重叠地执行所有的有「1」的行，则就可以按照任意的顺序执行。

${\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)\backslash m}{\mathrm{\&Sigma;}}{{\mathrm{\&alpha;}}^{,}}_{m^{,}n}^{\left(l\right)}={\mathrm{\&beta;}}_n^{\left(l\right)}-{\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}$

$S_m=S_m^{\&prime;}\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)$

$n_i=\arg \underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n_1,n_2,...,n_{i-1},n_i,n\}}{\min }[B_{{\mathrm{mn}}^{,}},|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(35\right)$

$B_{{\mathrm{mn}}_i}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n_1,n_2,...,n_{i-1},n_i,n\}}{\min }[B_{{\mathrm{mn}}^{,}},|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right],\&ForAll;i\&Element;[1,k]$

具体地讲，在列号码n中，把接收LLR：λ_n与在第l次行处理中被更新了的第m行以外的LLR：α_m’n ^(l)的合计值的相加结果作为更新后的LLR：β_mn ^(l)。该计算也可以通过从β_n ^(l)减去α_mn ^(l)得到。另外，通过把上述S_m’与第l次列处理中被更新了的β_mn ^(l)的符号(+或者-)相乘，更新在行处理中使用的S_m。另外，上述(35)式中的下面的2个公式规定了B_mn(l)的重新排列处理(最小k个值)。

(行处理步骤2)

进而，作为再次行处理，对于与在列号码n的列处理中执行的行相同的m，根据下述(36)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α’_mn ^(l)。

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

${S^{\&prime;}}_m=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\&CenterDot;\&CenterDot;\left(36\right)$

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}+{{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}$

具体地讲，作为再次行处理，更新α’_mn ^(l)，进而使用其结果，在β_mn ^(l)上加入其更新了的α’_mn ^(l)，更新β_n ^(l)。然后，对于列号码n的所有的m，直到计算结束为止，返回到列处理步骤中，反复进行计算。另外，对于在列号码n的检验矩阵中存在“1 ”的所有的行m，如果结束列处理步骤和行处理步骤2，则转移到停止规范的处理。

(停止规范)

然后，例如，在位n的第l次反复的后验值β_n ^(l)是「β_n ^(l)＞0」的情况下，把解码结果设为「x’＝1」(x’与原始的发送信号x相对应)，另一方面，在「β_n ^(l)≤0」的情况下，把解码结果设为「x’＝0」，得到解码结果x’＝(x₁’，x₂’，......，x_N’)。

而且，在奇偶检验的结果是「Hx’＝0」或者反复次数是「l＝l_max」的情况下(满足任意一个条件的情况下)，输出这时的解码结果x’。另外，在上述两个条件的任意一个都不满足的情况下，使「l＝l+1」，返回到上述行处理步骤1，以后按顺序执行运算。

接着，使用结构图具体说明执行上述「串行循环近似min算法」的LDPC解码器5的特征性的动作。

与上述的实施方式相同，图6表示在上述「串行循环近似min算法」中执行行处理的行处理部22的结构例子，该行处理部22由最小值选择部31、符号运算部32和LLR计算部33构成。另外，图示的Min1LLR(第m行中的最小的LLR)是B_mn(1)，Min2LLR(第m行中的第2个最小的LLR)是B_mn(2)，是分别保持在中间结果保持部21中的值。另外，关于图示的S_m以及「第(l-1)次的第m行n列的LLR：β_mn的符号」，也是分别保持在中间结果保持部21中的值。

在最小值选择部31中，在成为行处理的对象的列号码n与Min1LLR(B_mn(1))的列号码n(1)一致的情况下，选择Min2LLR(B_mn(2))，除此以外的情况下选择Min1LLR(B_mn(1))并输出。另外，符号运算部32把「在第(l-1)次的列处理中被更新了的S_m」以及「第(l-1)次的第m行m列的LLR：β_mn的符号」相乘，作为其结果输出S_m’。这时，S_m’保持在中间结果保持部21中。另外，LLR计算部33通过把从最小值选择部31得到的最小的LLR与从符号运算部32得到的符号的乘法结果S_m’(+或者-)相乘，计算LLR：α_mn ^(l)。依据该结构，能够把在「Min-Sum算法」中行权重大小的必要的存储器缩小为k个值大小。

图19是表示在上述「串行循环近似min算法」中执行列处理的列处理部23的结构例子的图，该列处理部23由α加法部41、λ加法部42、最小k个值比较部43和符号运算单部44构成。另外，在本实施方式中，作为一个例子记载k＝3的情况。另外，图示的列权重大小的LLR、α’_mn，α_mn，λ_n，S_m’，Min1LLR，Min2LLR，Min3LLR(第m行中第3个最小的LLR)是分别被保持在中间结果保持部21中的值。

在上述列处理部23中，α加法部41把包括在第l次的行处理中被更新了的第m行的所有的LLR：α_mn ^(l)相加，进而，λ加法部42在α加法部41的加法结果上加入接收LLR：λ_n，开关45控制成使得最初连接到其下面的块上，从那里减去α_mn ^(l)输出β_mn ^(l)。而后，最小k个值比较部43(k＝3)接收|β_mn ^(l)|。

这里，图19中虽然没有图示，然而与上述的实施方式相同，例如，在成为列处理对象的第n列的n与表示与分别保持在Min1LLR、Min2LLR、Min3LLR中的B_mn(1)、B_mn(2)、B_mn(3)相对应的列号码的n(1)、n(2)、n(3)的任一个一致的情况下，间拔成为n＝n(i)的B_mn(i)，进行图8表示的操作。具体地讲，删除保持在Min2LLR中的信息，把保持在Min3LLR中的信息移动到Min2LLR，进而在Min3LLR中，例如(16位的情况下)保存最大值“FFFF”。由此，在能够进行除去处理对象的列的比较处理的同时，至少Min3LLR在列处理中一定被更新。

该处理以后，如图19所示，把|β_mn ^(l)|与Min1LLR、Min2LLR、Min3LLR分别进行比较，如果是「|β_mn ^(l)|＜Min3LLR」，则更新最小3个值的LLR。另一方面，把λ加法部42输出的β_mn ^(l)的符号作为「第l次的第m行n列的LLR：β_mn ^(l)的符号」，保持在中间结果保持部21中，进而，符号运算部44把在第l次的行处理中被更新了S_m’与上述β_mn ^(l)的符号相乘，使用其结果更新保持在中间结果保持部21中的S_m。另外，在|β_mn ^(l)|与Min1LLR、Min2LLR、Min3LLR的比较时，最初把|β_mn ^(l)|与作为B_mn(i)的中心值的Min2LLR进行比较，然后，如图示那样，虽然树形地进行比较，然而例如与从作为最小值的Min1LLR开始进行比较的情况相比，具有执行时间变为{(k+1)/2}/k(k是奇数的情况)的效果。另外，在k是偶数的情况下，虽然B_mn(i)的中心的值成为2个，但最初开始比较的对象可以是任一个。在k是偶数的情况下，与从作为最小值的Min1LLR开始进行比较的情况相比，具有执行时间变为{k/2+1}/k(k是偶数的情况)的效果。从该比较的结果的Min1LLR和Min2LLR，根据图6的电路求α’_mn ^(l)，与β_mn ^(l)相加计算β_n ^(l)，由开关45转移到下一个列处理。

接着，使用图9的流程图说明本实施方式的「串行循环近似min算法」中的处理流程。另外，图中，在「第1次反复解码」、「第2次反复解码」、......「最末次反复解码」中，记载为处理「行处理」、「列处理」、「行处理」、......、「列处理」，而在本实施方式中，设在处理了「行处理步骤1」以后，对于列号码n的所有m直到计算结束为止，反复进行「列处理步骤」、「行处理步骤2」的反复处理。即，设处理「行处理步骤1」、「列处理步骤」、「行处理步骤2」、「列处理步骤」、「行处理步骤2」、「列处理步骤」、......、「行处理步骤2 」、「行处理步骤1」、「列处理步骤」、「行处理步骤2」、「列处理步骤」、「行处理步骤2」、「列处理步骤」、......、「行处理步骤2」。

在上述「串行循环近似min算法」中，首先，接收LLR计算部11从接收信息计算接收LLR(步骤S11、S12)，把其结果作为初始值，设定在中间结果保持部21中(步骤S13)，进而，控制部25把反复次数初始化为l＝1(步骤S13)。另外，列处理部23中，使用λ加法部42、最小k个值比较部43、符号运算部44，从n1到n＝N，循环进行上述(33)式的运算(步骤S13)。

接着，解码芯部12通过控制部25的控制，进行第l次(第1次～最末次)的反复解码运算(步骤S14)。具体地讲，作为反复解码的第1次，行处理部22对在第1列有“1 ”的行进行行处理步骤1(使用接收LLR)，把其结果交付到列处理部23。然后，列处理部23进行第1列的列处理步骤，把作为其结果的B_mn(i)和S_m保持在中间结果保持部21中(更新)。然后，行处理部22进行行处理步骤2，把其结果传递到列处理部23，由行处理部22和列处理部23反复进行列处理步骤和行处理步骤2。以后，按照第2列、第3列、......、第N列的顺序，进行与上述相同的处理，分别把B_mn(i)和S_m保持在中间结果保持部21中(相当于第1次反复解码)。然后，在反复解码的第2次以后，使用前一次的处理中被更新了的LLR以及S_m进行行处理，除此以外，与上述第1次相同，进行解码处理。

另外，在实施了上述第l次的反复解码以后，解码结果判定部24硬判定在第l次反复中计算出的后验值，把其判定值决定为解码结果x’，进而进行奇偶检验(停止规范)。而且，在该停止规范中，在奇偶检验结果成为OK(「Hx’＝0」)或者反复次数成为l＝l_max的情况下，最终输出这时的解码结果x’(步骤S15)。另外，在不满足上述2个条件的情况下，控制部25使l＝l+1，在解码芯部1 2中，执行第(l+1)次的反复解码。

接着，与上述的实施方式相同，说明基于列号码的记述方法的存储器尺寸的减少。图10是表示本实施方式的列号码标记的图。在「串行循环近似min算法」中，例如决定从n＝0按照升序标记列号码。另外，当前用奇偶检验矩阵的列号码自身(绝对列号码)表现列号码n，而在本实施方式中，把奇偶检验矩阵中的第m行的“1”的最小列号码作为n＝0，把第m行的下一个“1”的列号码作为n＝1，以后，对于每个“1”用设为n＝2、3、......的相对列号码表现。即，当前在奇偶检验矩阵的“1”的绝对列号码例如是“32768”的情况下，为了表现列号码所需要的位数为15位，而另一方面，在本实施方式中，例如如果行权重是8个，则把存储器尺寸缩小到能表现0～7的3位，如果行权重是16个，则把存储器尺寸缩小到能表现0～15的4位。

如上所述，在本实施方式中，在LDPC解码中，由于根据循环构造能够以行单位把用于行处理的LLR的绝对值|β_mn|缩小为最小k个值，因此能大幅度减少用于保持这些值的存储量。例如，在行权重是20，k＝3的情况下，与以往相比较，能够把存储量减少到3/20。另外，通过把列号码从绝对列号码(1、3、10、15......)变更成相对列号码(0、1、2、3......)，能进一步减少存储量。

另外，在本实施方式的「串行循环近似min算法」中，按照1位1位地循环进行基于行处理以及列处理的概率信息(LLR)的计算以及更新。由此，与现有的「Min-Sum算法」相比较能有效地进行概率传播。

另外，在本实施方式的「串行循环近似min算法」中，由于作为行处理步骤2，更新α’_mn ^(l)，进而使用其结果在β_mn ^(l)上加入该更新了的α’_mn ^(l)，更新β_n ^(l)，因此能够使得与完全的位单位的串行解码相对应，能进一步减少反复次数。

另外，在本实施方式中，行处理运算对象的LLR是单个值，而k的个数可以是2个值以上的任意值。另外，在本实施方式中，说明了在执行了行处理步骤1以后，交互执行列处理步骤和行处理步骤2，与此相对应，按照1位1位地循环进行基于行处理和列处理的概率信息(LLR)的更新的情况，但并不限于这种情况，也可以按照多个位多个位地循环进行基于行处理和列处理的概率信息(LLR)的计算以及更新。

实施方式7

接着，说明实施方式7的接收装置(通信装置)以及解码方法。本实施方式的LDPC解码能够应用于按照1位1位或者或者按照预先决定的多位多位地进行基于行处理以及列处理的概率信息(LLR)的计算以及更新，例如，通过使运算处理并行进行，谋求减少反复次数。另外，在本实施方式中，执行与并行的数量无关，把中间结果保持部的B_mn(i)以及S_m作为一组，并行了的所有的处理部更新同一个B_mn ^C以及S_m的使用了所谓「Overlapped」了的B_mn ^C以及S_m的「串行循环近似min算法」。以后，把本实施方式的解码算法称为「Overlapped串行循环近似min算法」。

这里，以下表示在本实施方式的接收装置中实施的「Overlapped串行循环近似min算法」。

(初始化步骤)

首先，设定反复次数l＝1以及最大反复次数l_max。进而，把初始时的第m行的最小k个值的LLR作为β_mn(i) ⁽⁰⁾，输入接收LLR：λ_n，如下述(37)式表示的那样求B_mn(i) ^C。另外，作为初始时的第m行的LLR：β_mn(i) ⁽⁰⁾的符号，输入sgn(λ_n)，如下述(37)式表示的那样求S_m。

$B_{{\mathrm{mn}}^{,}}^C=\left|{\mathrm{\&beta;}}_{\mathrm{mn}\left(i\right)}^{\left(0\right)}\right|=\underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right],\&ForAll;i\&Element;[1,k]$

$S_m=\underset{n\&Element;N\left(m\right)}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&lambda;}}_n\right)\&CenterDot;\&CenterDot;\&CenterDot;\left(37\right)$

$n\left(i\right)=\arg \underset{n\&Element;N\left(m\right)\backslash \{n\left(1\right),n\left(2\right),...,n(i-1)\}}{\min }\left[\right|{\mathrm{\&lambda;}}_n\left|\right]$

n(0)＝φ

式中，B_mn(i)是第m行的最小k个值的LLR：β_mn(i)的绝对值，在并行处理时共同使用。另外，n(i)是在B_mn(i) ^C中第i个最小的LLR的列号码。

(行处理步骤1)

接着，作为行处理，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G 以及各个m，根据下述中(38)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α_mn ^(l)。另外，G是并行数，N_G是并行的各解码电路处理的列数。另外，G·N_g＝N。另外，在本实施方式中，各行处理的开始列为任意列，在至最末列处理结束了的阶段，再次从最初的列开始循环进行解码处理。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}^C\right]$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(38\right)$

$S_m^{\&prime;}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)$

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m\&Element;M\left(n\right)}{\mathrm{\&Sigma;}}{\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}$

具体地讲，例如，对每个列数：N_G被分割为G个的各列区中分别分配的G个行处理部并行执行行处理。另外，G个行处理部并行进行处理，所有的处理部除去使用相同B_mn ^C以外，与上述的「串行循环近似min算法」同样进行动作。

(列处理步骤)

接着，作为列处理，对于在行处理步骤1中进行的列号码n的各个m，根据下述(39)式更新从位节点n向检查节点m传送的位n的第l次反复的LLR：β_mn ^(l)。即，在本实施方式中，对于如上述那样并行进行了行处理后的各列，并行执行下述(39)式表示的列处理。其中，在并行进行列处理时，对于成为处理对象的列号码n，其以后的列处理步骤以及行处理步骤2例如从行号码m的最小行号码开始顺序地按照1行1行地执行计算。其中，如果所执行的行号码的顺序不重复地执行所有的有「1」的行，则也可以按照任意的顺序来执行。

${\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}={\mathrm{\&lambda;}}_n+\underset{m^{,}\&Element;M\left(n\right)\backslash m}{\mathrm{\&Sigma;}}{{\mathrm{\&alpha;}}^{,}}_{m^{,}n}^{\left(l\right)}={\mathrm{\&beta;}}_n^{\left(l\right)}-{\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}$

$S_m=S_m^{\&prime;}\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)$

$n_i=\arg \underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n_1,n_2,...,n_{i-1},n_i,n\}}{\min }[B_{{\mathrm{mn}}^{,}}^C,|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(39\right)$

$B_{{\mathrm{mn}}_i}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash \{n_1,n_2,...,n_{i-1},n_i,n\}}{\min }[B_{{\mathrm{mn}}^{,}}^C,|{\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\left|\right],\&ForAll;i\&Element;[1,k]$

(行处理步骤2)

进而，作为再次行处理，对于与在列号码n的列处理中执行的行相同的m，根据下述(40)式更新从检查节点m向位节点n传送的位n的第l次反复的LLR：α’ _mn ^(l)。

${S^{\&prime;}}_m=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\&CenterDot;\&CenterDot;\left(40\right)$

${\mathrm{\&beta;}}_n^{\left(l\right)}={\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}+{{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}$

具体地讲，作为再次行处理，更新α’_mn ^(l)，进而使用其结果在β_mn ^(l)上加入其更新了的α’_mn ^(l)，更新β_n ^(l)。然后，直到对于列号码n的所有的m计算结束为止，返回到列处理步骤，反复进行计算。另外，如果对于与列号码n的检验矩阵中有“1”的所有的行m，列处理步骤和行处理步骤2的处理结束，则转移到停止规范的处理。

另外，关于停止规范，与上述的「串行循环近似min算法」相同。

接着，说明实现上述「Overlapped串行循环近似min算法」的实施方式7的LDPC解码器5的结构以及动作。

图13是与上述的实施方式相同，表示本实施方式LDPC解码器5的结构例子的图，由从接收信息计算接收LLR的接收LLR计算部11和进行本实施方式的解码处理的解码芯部12a构成。另外，解码芯部12a具备由用于预先保持解码的中间结果(中间值)的存储器构成的中间结果保持部21a、执行本实施方式的行处理(并行处理)的行处理部22-1～22-G、执行本实施方式的列处理(并行处理)的列处理部23-1～23-G、作为本实施方式的停止规范进行列处理中的后验值的硬判定以及奇误检验结果的正误判定的解码结果判定部24、进行解码的反复控制的控制部25a。

图13中，本实施方式的LDPC解码器5的各行处理部以及各列处理部并行进行处理时，遵从上述(37)式、(38)式、(39)式、(40)式，共同使用中间结果保持部21a的B_mn ^C以及S_m，分别进行更新。通过该并行处理，B_mn ^C以及S_m根据并行数急速变更，与此相伴随，能大幅度减少解码的反复次数。

另外，在本实施方式中，在并行处理中，在同一块上发生了同一行的运算，产生了参照同一个缓冲器的问题的情况下，例如，进行在各处理部中设定存储器访问的优先顺序、划分存储体、使用移位寄存器调整存储器访问的定时等对策。

如上所述，本实施方式的「Overlapped串行循环近似min算法」应用上述的「串行循环近似min算法」，分别并行执行行处理以及列处理。另外，对保持在并行执行的各列处理中被更新的最小k个值的中间结果保持部进行共有，在并行执行的各列处理中分别更新最小k个值。由此，与「Min-Sum算法」以及上述的实施方式6相比较，能大幅度减少解码的反复次数。

另外，在本实施方式的「Overlapped串行循环近似min算法」中，作为行处理步骤2，更新α’_mn ^(l)，进而使用其结果，在β_mn ^(l)上加入其更新了的α’_mn ^(l)，更新β_n ^(l)，因此能够与完全的位单位的串行解码对应，与上述的实施方式2相比较，能够进一步减少反复次数。

实施方式8

接着，说明实施方式8的接收装置(通信装置)以及解码方法。在本实施方式中，对于应用了「Min-Sum算法」的作为已知的解码算法的「Normalized BP-based算法」，应用实施方式6的「串行循环近似min算法」或者实施方式7的「Overlapped串行循环近似min算法」中的仅循环更新最小k个值的LLR的绝对值的处理以及使用了近似最小值的解码处理。

这里，在对于本实施方式的解码算法进行说明之前，以下表示成为其前提的已知的「Normalized BP-based算法」。另外，这里说明与「Min-Sum算法」的处理不同的行处理。

(行处理步骤1)

例如，如果把「Normalized BP-based算法」的处理步骤1一般化，则能够如下述(41)式那样表示。这里，作为行处理步骤1，对于各个m、n，根据下述(41)式更新第l次反复的LLR：α_mn ^(l)。另外，式中的A是称为标准化因子的常数，在「Normalized BP-based算法」中，根据标准化因子A修正由「Min-Sum算法」得到的第l次反复的LLR。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}={2\tanh }^{-1}\left(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}}{2}\right)\right)$

$={2\tanh }^{-1}(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right))\&CenterDot;\&CenterDot;\&CenterDot;\left(41\right)$

$=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;{2\tanh }^{-1}\left(\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\tanh \left(\frac{\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|}{2}\right)\right)$

$\&ap;\frac{1}{A}\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\min }\left|{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right|$

接着，以下表示对于上述「Normalized BP-based算法」应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」时的解码算法。另外，在本实施方式中，对于与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」同样的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」的不同处理的行处理步骤1。

(应用了串行循环近似min算法时的行处理步骤(1))

例如，如果把应用了「串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(42)式那样表示。这里，作为行处理步骤1，对于各个m、n，根据下述(42)式更新第l次反复的LLR：α_mn ^(l)。即，在下述(42)式中，根据标准化因子A修正由「串行循环近似min算法」得到的第l次反复的LLR。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环进行解码处理。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\frac{1}{A}\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

$=\frac{1}{A}{S}_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(42\right)$

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(n\right)}=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}\right]$

(应用了Overlapped串行循环近似min算法时的行处理步骤1)

另外，如果把应用了「Overlapped串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(43)式那样表示。这里，作为行处理步骤1，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(43)式更新第l次反复的LLR：α_mn ^(l)。即，在下述(43)式中，根据标准化因子A修正由「Overlapped串行循环近似min算法」得到的第l次反复的LLR。

${\mathrm{\&alpha;}}_{\mathrm{mn}}^{\left(l\right)}=\frac{1}{A}\underset{\underset{n^{,}<g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]$

$=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(43\right)$

$=\frac{1}{A}{S}_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[{B^C}_{{\mathrm{mn}}^{,}}\right]$

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}=\frac{1}{A}{S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\min }\left[B_{{\mathrm{mn}}^{,}}^C\right]$

另外，在本实施方式的解码算法中，在如上述那样执行了行处理步骤1以后，进而执行与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」同样的行处理以及基于停止规范的处理，得到最终的解码结果。

接着，使用附图说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或者图13相同。

图15与上述的实施方式相同，表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子，该行处理部具备最小值选择部31a。另外，关于与上述的图6相同的结构标注相同的符号，省略其说明。在本实施方式的最小值选择部31a中，例如使用标准化因子A修正从中间结果保持部21(或者21a)中读出的LLR的最小值(Min1LLR或者Min2LLR)。具体地讲，通过用A除LLR的最小值进行标准化。

如上所述，在本实施方式中，在性能比「Min-Sum算法」良好的「Normalized BP-based算法」中应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」。由此，可以得到与上述的实施方式6、7相同的效果，并且，进而尽管是与「Min-Sum算法」几乎同等的电路量，但也能实现接近「Sum-Product算法」的性能。

另外，在本实施方式中，在「Normalized BP-based算法」中应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」，但并不限于这种情况，也能在已知的「Offset BP-based算法」或者除此以外的算法中应用「串行循环近似min算法」或者「Overlapped串行循环近似min算法」，关于这样的情况，也能得到与上述相同的效果。

实施方式9

接着，说明实施方式9的接收装置(通信装置)以及解码方法。在本实施方式中，对于作为LLR：β_mn的修正性能比「Normalized BP-based算法」或者「Offset BP-based算法」出色的已知的解码算法的「δmin算法」，应用实施方式6的「串行循环近似min算法」或者实施方式7的「Overlapped串行循环近似min算法」中的仅循环更新最小k个值的LLR的绝对值的处理以及使用了近似最小值的解码处理。

这里，在对于本实施方式的解码算法进行说明之前，以下表示作为其前提的已知的「δmin算法」。另外，这里对于与「Min-Sum算法」的处理不同的行处理进行说明。

(行处理步骤1)

例如，如果把「δmin算法」的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(44)式那样表示。这里，作为行处理步骤1，对于各个m、n，根据下述(44)式更新第l次反复的LLR：α_mn ^(l)。在「δmin算法」的行处理步骤1中，根据在第l-1次反复中更新了的LLR的绝对值：|β_mn’ ^(l-1)|，通过Θ的运算计算α_mn ^(l)。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[\right|{\mathrm{\&beta;}}_{m,n^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{\&Theta;}}\left(I_n\right)\&equiv;I_1\mathrm{\&Theta;}{I}_2\mathrm{\&Theta;}\&CenterDot;\&CenterDot;\&CenterDot;\mathrm{\&Theta;}{I}_{\left|A\right|}$

aΘb≡max(min(a，b)-Δ，0)    …(44)

Δ≡max(0.9-|a-b|/2，0)

${{\mathrm{\&alpha;}}^{,}}_{m,n}^{\left(l\right)}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}\right]$

接着，以下表示对于上述「δmin算法」应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」时的解码算法。另外，在本实施方式中，对于与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」同样的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」的不同处理的行处理步骤1。另外，在本实施方式中，行处理的开始列为任意，在至最末列处理结束了的阶段，再次从最初的列开始循环进行解码处理。

(应用了串行循环近似min算法时的行处理步骤1)

例如，如果把应用了「串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(45)式那样表示。这里，作为行处理步骤1，对于1≤n≤N以及各个m，根据下述(45)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理步骤1中，根据在第l-1次反复中被更新了的最小k个值的LLR的绝对值：B_mn’，通过Θ的运算计算α_mn ^(l)。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(45\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

${{\mathrm{\&alpha;}}^{,}}_{m,n}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}\right]$

(应用了Overlapped串行循环近似min算法时的行处理步骤1)

另外，如果把应用了「Overlapped串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(46)式那样表示。这里，作为行处理步骤1，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(46)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理步骤1中，从在第l-1次反复中按照并行处理被更新了的最小k个值的LLR的绝对值：B_mn’ ^C，通过Θ的运算计算α_mn ^(l)。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(46\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

${{\mathrm{\&alpha;}}^{,}}_{m,n}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

另外，在本实施方式的解码算法中，在如上述那样执行了行处理步骤1以后，进而执行与上述的「串行循环近似min算法」或者「Overlapped串行循环近似min算法」同样的列处理、行处理步骤2以及基于停止规范的处理，得到最终的符号结果。

接着，使用附图，说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或者图13相同。

图16是与上述的实施方式相同，表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子的图，该行处理部具备最小值选择部31b。另外，关于与上述的图6相同的结构标注相同的号码，省略其说明。另外，这里作为一个例子，说明了图5的LDPC解码器5的情况，而对于图13的LDPC解码器5也同样能够适用。

在本实施方式的最小值选择部31b中，例如从中间结果保持部21读出Min1LLR(B_mn(1))、Min2LLR(B_mn(2))、MinkLLR(B_mn(k))和各自的列号码，运算部进行Θ的运算。即，在本实施方式的最小值选择部31b中，对于成为处理对象的第n列与保持在中间结果保持部21中的B_mn(k)的列号码n(k)不一致的B_mn(k)，运算部进行「δmin算法」中的以下的运算。

例如，运算部如下述(47)式那样求除去符号的更新值|α_mn ^(l)|(＝Θ[B_mn’])。

$\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(47\right)$

另外，通过把运算对象的LLR从k个值限定为最小3个值，能够减少运算量，运算部如下述(48)式那样求除去符号的更新值|α_mn ^(l)|(＝Θ[B_mn’])。

[数44]

如果 $(n=n_{\left(1\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(2\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(3\right)}}$

否则如果 $(n=n_{\left(2\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(3\right)}}\&CenterDot;\&CenterDot;\&CenterDot;\left(48\right)$

否则 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Theta;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Theta;}{B}_{{\mathrm{mn}}_{\left(2\right)}}$

另外，上述中作为一个例子说明了把运算对象的LLR从k个值限定为最小3个值的情况，而即使限定为最小4、5......的情况下也同样能够适用。

如上所述，在本实施方式中，在性能比「Min-Sum算法」良好「δmin算法」中应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」。由此，可以得到与上述的实施方式6、7同样的效果的同时，进而，尽管是与「Min-Sum算法」几乎同等的电路量，也能够实现接近「Sum-Product算法」的性能。另外，在本实施方式中，记载了根据在已知的「δmin算法」中规定的预定的修正式把行处理用的LLR的绝对值的最小值修正为最佳值的情况，但修正式并不限于该式，也可以使用在「δmin算法」以外的算法中规定的修正式。这种情况下也能够得到与上述相同的效果。

实施方式10

接着，说明实施方式10的接收装置(通信装置)以及解码方法。在本实施方式中，对于「sum-product算法」应用实施方式6的「串行循环近似min算法」或者实施方式7的「Overlapped串行循环近似min算法」中的仅循环地更新最小k个值的LLR的绝对值的处理以及使用了近似最小值的解码处理。

这里，在对本实施方式的解码算法进行说明之前，以下表示成为其前提的已知的「Sum-Product算法」。另外，在本实施方式中，记载对数学函数进行表处理来进行运算的方法、即，利用了TLU(表查找)的一般的「Sum-Product算法」。另外，这里，记载与在现有技术中说明过的「Sum-Product算法」的处理不同的行处理。

(行处理步骤1(1))

例如，如果把利用了TLU的「Sum-Product算法」的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(49)式那样表示。这里，作为行处理步骤1，对于各个m、n，根据下述(49)式更新第l次反复的LLR：α_mn ^(l)。在利用了TLU的「Sum-Product算法」的行处理步骤1中，对于在第l-1次反复中被更新了的LLR的绝对值：|β_mn’ ^(l-1)|，进行使用了TLU的运算。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{TLU}}\left[\right|{\mathrm{\&beta;}}_{{m,n}^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{TLU}}\left(I_n\right)\&equiv;\mathrm{TLU}(I_1,\mathrm{TLU}(I_2,\&CenterDot;\&CenterDot;\&CenterDot;\mathrm{TLU}(I_{\left|A\right|-1},I_{\left|A\right|})))$

$\mathrm{TLU}(a,b)\&equiv;{2\tanh }^{-1}(\tanh \frac{a}{2}\&CenterDot;\tanh \frac{b}{2})\&CenterDot;\&CenterDot;\&CenterDot;\left(49\right)$

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right]$

(行处理步骤1(2))

另外，按照与上述不同的方法，也能够实现利用了TLU的「Sum-Product算法」的行处理步骤1。例如，如果把与上述不同的利用了TLU的「Sum-Product算法」的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，则能够如下述(50)式那样表示。这里，作为行处理步骤1，对于各个m、n，根据下述(50)式更新第l次反复的LLR：α_mn ^(l)。

${\mathrm{\&alpha;}}_{m,n}^{\left(i\right)}=\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(i-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[\right|{\mathrm{\&beta;}}_{m,n^{,}}^{(i-1)}\left|\right]$

$\underset{n\&Element;A}{\mathrm{\&Xi;}}\left(I_n\right)\&equiv;I_1\mathrm{\&Xi;}{I}_2\mathrm{\&Theta;}\&CenterDot;\&CenterDot;\&CenterDot;\mathrm{\&Xi;}{I}_{\left|A\right|}\&CenterDot;\&CenterDot;\&CenterDot;\left(50\right)$

aΞb≡min(a，b)+TLU1(|a+b|)-TLU1(|a-b|)

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}=\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right]$

另外，TLU1(x)根据下述(51)预先准备表。

TLU1(x)＝ln(1+exp(-x))    ......(51)

另外，在上述利用了TLU的「Sum-Product算法」中，上述(49)式表示的行处理步骤1具有虽然表变大但是运算次数少的特征，另一方面，上述(50)式表示的行处理步骤1具有虽然表变小但是运算次数多的特征。

接着，以下表示对于上述利用了TLU的「Sum-Product算法」，应用了「串行循环近似min算法」时的解码算法。另外，在本实施方式中，关于与上述「串行循环近似min算法」相同的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述「串行循环近似min算法」的处理不同的行处理步骤1。另外，在本实施方式中，行处理的开始列为任意，在至最末列为止处理结束了的阶段，再次从最初的列开始循环地进行解码处理。

(应用了串行循环近似min算法时的行处理步骤1(1))

例如，如果对于上述行处理步骤1(1)，把应用了「串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，能够如下述(52)式那样表示。这里，作为行处理步骤1，对于1≤n≤N以及各个m，根据下述(52)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理步骤1中，对于在第l-1次反复中被更新了的最小k个值的LLR的绝对值：B_mn’，进行使用了TLU的运算。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]$

${=S}_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(52\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]$

${{\mathrm{\&alpha;}}^{,}}_{\mathrm{mn}}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}\right]$

(应用了串行循环近似min算法时的行处理步骤1(2))

另外，如果对于上述行处理步骤1(2)，把应用了「串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，能够如下述(53)式那样表示。这里，作为行处理步骤1，对于1≤n≤N以及各个m，根据下述(53)式更新第l次反复的LLR：α_mn ^(l)。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>n}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(53\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]$

${{\mathrm{\&alpha;}}^{,}}_{m,n}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[{\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}\right]$

接着，以下表示对于上述利用了TLU的「Sum-Product算法」，应用了「Overlapped串行循环近似min算法」时的解码算法。另外，在本实施方式中，关于与上述「Overlapped串行循环近似min算法」相同的处理(初始化、列处理、停止规范)，省略其说明。以下，说明与上述「Overlapped串行循环近似min算法」的处理不同的行处理步骤1。

(应用了Overlapped串行循环近似min算法时的行处理步骤1(1))

例如，如果对于上述行处理步骤1(1)，把应用了「Overlapped串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，能够如下述(54)式那样表示。这里，作为行处理步骤1，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(54)式更新第l次反复的LLR：α_mn ^(l)。另外，在该解码算法的行处理步骤1中，对于在第l-1次反复中以并行处理被更新了的最小k个值的LLR的绝对值：B_mn’ ^C，进行使用了TLU的运算。

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(54\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

${{\mathrm{\&alpha;}}^{,}}_{mn}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

(应用了Overlapped串行循环近似min算法时的行处理步骤1(2))

另外，如果对于上述行处理步骤1(2)，把应用了「Overlapped串行循环近似min算法」时的本实施方式的解码算法的行处理步骤1、2的α_mn ^(l)、α’_mn ^(l)一般化，能够如下述(55)式那样表示。这里，作为行处理步骤1，对于0≤g≤G-1，g·N_G+1≤n≤(g+1)·N_G以及各个m，根据下述(55)式更新第l次反复的LLR：α_mn ^(l)。

${\mathrm{\&alpha;}}_{mn}^{\left(l\right)}=\underset{\underset{n^{,}<g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{\left(l\right)}\right)\&CenterDot;\underset{\underset{n^{,}>g\&CenterDot;N_G}{n^{,}\&Element;N\left(m\right)\backslash n}}{\mathrm{\&Pi;}}\mathrm{sgn}\left({\mathrm{\&beta;}}_{{\mathrm{mn}}^{,}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

$=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{(l-1)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(55\right)$

$=S_m^{\&prime;}\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

${{\mathrm{\&alpha;}}^{,}}_{m,n}^{\left(l\right)}=S_m\&CenterDot;\mathrm{sgn}\left({\mathrm{\&beta;}}_{\mathrm{mn}}^{\left(l\right)}\right)\&CenterDot;\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}^C\right]$

接着，使用附图说明执行上述本实施方式的解码算法的LDPC解码器5的行处理部的特征性的动作。另外，关于LDPC解码器5的整体结构，与上述的图5或者图13相同。

图18与上述的实施方式相同，是表示执行本实施方式中的行处理的行处理部22、22-1～22-G的结构例子的图，该行处理部具备最小值选择部31c。另外，关于与上述的图6相同的结构标注相同的符号，省略其说明。另外，这里，作为一个例子，说明了图5的LDPC解码器5的情况，而对于图13的LDPC解码器5也同样能够适用。

在本实施方式的最小值选择部31c中，例如从中间结果保持部21读出Min1LLR(B_mn(1))、Min2LLR(B_mn(2))、MinkLLR(B_mn(k))和各个列号码，运算部进行使用了TLU的运算。即，在本实施方式的最小值选择部31c中，对于成为处理对象的第n列与保持在中间结果保持部21中的B_mn(k)的列号码n(k)不一致的B_mn(k)，运算部进行「Sum-Product算法」中的以下的运算。

例如，运算部如下述(56)式那样求除去符号的更新值。

[数51]

$\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TUL}}\left[B_{{\mathrm{mn}}^{,}}\right]$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]\&CenterDot;\&CenterDot;\&CenterDot;\left(56\right)$

另外，通过把运算对象的LLR从k个值限定为最小3个值，能够减少运算量，运算部如下述(57)式那样求除去符号的更新值。

[数52]

如果 $(n=n_{\left(1\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}\left(B_{{\mathrm{mn}}_{\left(2\right)}}{,B}_{{\mathrm{mn}}_{\left(3\right)}}\right)$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(2\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(3\right)}}$

否则  如果 $(n=n_{\left(2\right)})\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}(B_{{\mathrm{mn}}_{\left(1\right)}},B_{{\mathrm{mn}}_{\left(3\right)}})$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(3\right)}}\&CenterDot;\&CenterDot;\&CenterDot;\left(57\right)$

否则 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{TLU}}\left[B_{{\mathrm{mn}}^{,}}\right]=\mathrm{TLU}(B_{{\mathrm{mn}}_{\left(1\right)}},B_{{\mathrm{mn}}_{\left(2\right)}})$ 或者 $\underset{n^{,}\&Element;N_k\left(m\right)\backslash n}{\mathrm{\&Xi;}}\left[B_{{\mathrm{mn}}^{,}}\right]=B_{{\mathrm{mn}}_{\left(1\right)}}\mathrm{\&Xi;}{B}_{{\mathrm{mn}}_{\left(2\right)}}$

另外，上述中，作为一个例子说明了把运算对象的LLR从k个值限定为最小3个值的情况，而即使限定为最小4、5......的情况下也同样能够适用。

如上所述，在本实施方式中，对利用了TLU的「Sum-Product算法」应用了「串行循环近似min算法」或者「Overlapped串行循环近似min算法」。由此，与其它的实施方式相比较，虽然计算量以及存储量多，但是能够使解码性能提高。另外，在本实施方式中，作为例子说明了使用TLU的「Sum-Product算法」，而在对于数学函数进行TLU的其它解码算法中也相同。另外，在本实施方式中，记载了对于行处理用的LLR的绝对值的最小值，使用在已知的「Sum-Product算法」中规定的TLU的情况，而TLU并不受此限制，也可以使用在「Sum-Product算法」中规定的TLU以外的TLU。这种情况下也能够得到与上述相同的效果。

以上在各实施方式中，把行处理的开始列设为1，按照升序进行了处理，但并不受此限制。例如，也可以把开始列设为任意，对不重复的任意列进行处理，在所有的列结束了的阶段，再次按照相同的顺序进行反复解码。或者，也可以把行处理的列取为任意，对不重复的任意列进行处理，在所有的列结束的阶段，继续按照不同的顺序对不重复的任意列直到所有的列结束为止进行反复解码。在这些处理中，也可以得到与上述各实施方式同样的效果。另外，在上述实施方式的说明中，说明了作为概率信息使用对数似然比LLR的情况，而也可以使用对数似然比LLR以外的概率信息。

产业上的可利用性

如上所述，本发明的接收装置以及解码方法作为数字通信中的纠错技术是有用的，特别适于把LDPC编码后的信号进行解码的通信装置。

Claims (30)

1. 一种通信装置，该通信装置使用检验矩阵把被LDPC编码过的码字进行解码，其特征在于，具备：

保持通过解码算法中的规定处理得到的中间值的保持单元；

根据与检验矩阵中的行权重相对应的对数似然比(从位节点向检查节点发送的对数似然比：称为行处理用LLR)的绝对值，执行运算在列处理中使用的对数似然比(从检查节点向位节点发送的对数似然比：称为列处理用LLR)的行处理的行处理单元；

执行使用与列权重相对应的列处理用LLR，运算在行处理中使用的行处理用LLR，进一步把行处理用LLR的绝对值的最小k个值保持在上述保持单元中的列处理的列处理单元，

上述列处理单元在更新行的上述最小k个值的同时进行解码。

2. 根据权利要求1所述的通信装置，其特征在于，

把上述检验矩阵的列分割为规定数量，以分割后的行列单位并行地执行上述行处理以及列处理，进而，共有保持上述最小k个值的上述保持单元的区域，在并行地执行的各列处理中分别更新上述最小k个值。

3. 根据权利要求1所述的通信装置，其特征在于，

上述行处理单元通过把与上述行权重相对应的行处理用LLR的绝对值的最小值与上述行处理用LLR的符号的乘法结果进行相乘，求在接着的列处理中使用的列处理用LLR。

4. 根据权利要求3所述的通信装置，其特征在于，

上述行处理单元进而根据预先规定的固定的标准化因子，修正上述行处理用LLR的绝对值的最小值，使用修正后的值求列处理用LLR。

5. 根据权利要求1所述的通信装置，其特征在于，

上述行处理单元根据规定的修正式把与上述行权重相对应的行处理用LLR的绝对值的最小值修正为最佳值，通过把修正后的值与上述行处理用的LLR的符号的乘法结果相乘，求在接着的列处理中使用的列处理用LLR。

6. 根据权利要求1所述的通信装置，其特征在于，

上述行处理单元对于与上述行权重相对应的行处理用LLR的绝对值的最小值，进行使用了TLU(表查找)的规定运算，通过把该运算处理后的值与上述行处理用LLR的符号的乘法结果相乘，求在接着的列处理中使用的列处理用LLR。

7. 根据权利要求3～6中任意一项所述的通信装置，其特征在于，

上述行处理单元在第1次反复中，在将与特定的行中的行权重相对应的行处理用LLR的符号相乘的情况下，对于比处理对象的列号码小的列号码，乘以在第1次反复的列处理中被更新了的行处理用LLR的符号，另外，对于比处理对象的列号码大的列号码，乘以在第(1-1)次反复的列处理中被更新了的行处理用LLR的符号，进而，把这些乘法结果之间相乘。

8. 根据权利要求3～6中任意一项所述的通信装置，其特征在于，

上述行处理单元在第1次反复中，在将与特定的行中的行权重相对应的行处理用LLR的符号相乘的情况下，把与第(1-1)次反复的列处理中被更新了的行权重相对应的行处理用LLR的符号的乘法结果S与对应于处理对象的列号码的在第(1-1)次反复的列处理中被更新了的行处理用LLR的符号进行相乘，把该乘法结果S’保持在上述保持单元中。

9. 根据权利要求8所述的通信装置，其特征在于，

上述列处理单元在第1次反复中进行对于特定的列的列处理的情况下，

把与处理对象的列号码相对应的接收LLR与在第1次行处理中被更新了的与处理对象的行号码以外的列权重相对应的列处理用LLR的合计值的加法结果作为行处理用LLR，在该行处理用LLR的绝对值比处理对象的行的最小k个值中至少一个小的情况下，更新该最小k个值，

进而，把作为上述加法结果的行处理用LLR的符号与保持在上述保持单元中的符号的乘法结果S’相乘，把该乘法结果更新为在第(1+1)次反复的行处理中使用的符号的乘法结果S。

10. 一种通信装置，该通信装置使用检验矩阵把被LDPC编码过的码字进行解码，其特征在于，具备：

根据与检验矩阵中的行权重相对应的对数似然比(从位节点向检查节点发送的对数似然比：称为行处理用LLR)的绝对值，执行运算在列处理中使用的对数似然比(从检查节点向位节点发送的对数似然比：称为列处理用LLR)的行处理的行处理单元；

执行使用与列权重相对应的列处理用LLR，运算在行处理中使用的行处理用LLR的列处理的列处理单元，

上述行处理单元和上述列处理单元每次按照规定次数交互进行处理，循环地进行上述行处理用LLR以及列处理用LLR的更新。

11. 根据权利要求10所述的通信装置，其特征在于，

上述行处理单元通过把与上述行权重相对应的行处理用LLR的绝对值的最小值与上述行处理用的LLR的符号的乘法结果进行相乘，求在接着的列处理中使用的列处理用LLR。

12. 根据权利要求11所述的通信装置，其特征在于，

上述行处理单元进而根据预先规定的固定的标准化因子，修正上述行处理用LLR的绝对值的最小值，使用修正后的值求列处理用LLR。

13. 根据权利要求10所述的通信装置，其特征在于，

上述行处理单元根据规定的修正式把与上述行权重相对应的行处理用LLR的绝对值的最小值修正为最佳值，通过把修正后的值与上述行处理用LLR的符号的乘法结果相乘，求在接着的列处理中使用的列处理用LLR。

14. 根据权利要求10所述的通信装置，其特征在于，

上述行处理单元对于与上述行权重相对应的行处理用LLR的绝对值的最小值，进行使用了TLU(表查找)的规定运算，通过把该运算处理后的值与上述行处理用LLR的符号的乘法结果相乘，求在接着的列处理中使用的列处理用LLR。

15. 根据权利要求10～14中任意一项所述的通信装置，其特征在于，

上述行处理单元在第1次反复中，在将与特定的行中的行权重相对应的行处理用LLR的符号相乘的情况下，对于比处理对象的列号码小的列号码，乘以在第1次反复的列处理中被更新了的行处理用LLR的符号，另外，对于比处理对象的列号码大的列号码，乘以在第(1-1)次反复的列处理中被更新了的行处理用LLR的符号，进而，把这些乘法结果相互相乘。

16. 根据权利要求1或10所述的通信装置，其特征在于，

上述行处理单元在第1次反复的解码时，作为上述最小值，使用接收LLR的绝对值的最小值。

17. 根据权利要求1或10所述的通信装置，其特征在于，

上述列处理单元在每次执行上述列处理时计算后验值，硬判定该后验值，在奇偶检验结果是OK或者反复次数是所规定的最大次数的情况下，作为解码结果输出这时的硬判定值。

18. 根据权利要求1或10所述的通信装置，其特征在于，

设上述行处理的开始列为任意，在至最末列为止处理结束了的阶段，再次从最初的列开始进行反复解码。

19. 根据权利要求1或10所述的通信装置，其特征在于，

设上述行处理的开始列为任意，对不重复的任意列进行处理，在所有的列都结束了的阶段，再次按照相同的顺序进行反复解码。

20. 根据权利要求1或10所述的通信装置，其特征在于，

设上述行处理的开始列为任意，对不重复的任意列进行处理，在所有的列都结束了的阶段，接着以不同的顺序对于不重复的任意列直到所有的列结束为止进行反复解码。

21. 根据权利要求1或10所述的通信装置，其特征在于，

按照列号码小的顺序，从0开始以升序标记检验矩阵中的行权重的列号码。

22. 一种解码方法，该解码方法使用检验矩阵把被LDPC编码过的码字进行解码，其特征在于，

在更新行的最小k个值的同时，执行以下步骤来进行解码，

根据与检验矩阵中的行权重相对应的对数似然比(从位节点向检查节点发送的对数似然比：称为行处理用LLR)的绝对值，执行运算在列处理中使用的对数似然比(从检查节点向位节点发送的对数似然比：称为列处理用LLR)的行处理的行处理步骤；

执行使用通过上述行处理所运算的与列权重相对应的列处理用LLR，运算在行处理中使用的行处理用LLR，进而把与行权重对应的行处理用LLR的绝对值的最小k个值保持在存储器的特定区域中的列处理的列处理步骤。

23. 一种解码方法，该解码方法使用检验矩阵把被LDPC编码过的码字进行解码，其特征在于，

分别按照规定次数交互地执行以下步骤，循环地进行行处理用LLR以及列处理用LLR的更新，

根据与检验矩阵中的行权重相对应的对数似然比(从位节点向检查节点发送的对数似然比：称为行处理用LLR)的绝对值，执行运算在列处理中使用的对数似然比(从检查节点向位节点发送的对数似然比：称为列处理用LLR)的行处理的行处理步骤；

执行使用通过上述行处理运算出的与列权重相对应的列处理用LLR，运算在行处理中使用的行处理用LLR的列处理的列处理步骤。

24. 根据权利要求22或23所述的解码方法，其特征在于，

在上述行处理步骤中，为了计算列处理用LLR，还使用上述行处理用LLR的符号的乘法结果。

25. 根据权利要求24所述的解码方法，其特征在于，

在上述行处理步骤中，在第1次反复中，在将与特定的行中的行权重相对应的行处理用LLR的符号相乘的情况下，对于比处理对象的列号码小的列号码，乘以在第1次反复的列处理中被更新了的行处理用LLR的符号，另外，对于比处理对象的列号码大的列号码，乘以在第(1-1)次反复的列处理中被更新了的行处理用LLR的符号，进而，把这些乘法结果相互相乘。

26. 根据权利要求24所述的解码方法，其特征在于，

在上述行处理步骤中，在第1次反复中，将与特定的行中的行权重相对应的行处理用LLR的符号相乘的情况下，把在第(1-1)次反复的列处理中被更新了的与行权重相对应的行处理用LLR的符号的乘法结果S与对应于处理对象的列号码的在第(1-1)次反复的列处理中被更新了的行处理用LLR的符号进行相乘，把该乘法结果S’保持在存储器的特定区域中。

27. 根据权利要求26所述的解码方法，其特征在于，

在上述列处理步骤中，在第1次反复中进行针对特定列的列处理的情况下，

把对应于处理对象的列号码的接收LLR以及在第1次的行处理中被更新了的与处理对象的行号码以外的列权重相对应的列处理用LLR的合计值的相加结果作为行处理用LLR，在该行处理用LLR的绝对值比处理对象的行的最小k个值中的至少一个小的情况下，更新该最小k个值，

进而，把作为上述相加结果的行处理用LLR的符号与保持在上述存储器的特定区域中的符号的乘法结果S’相乘，把该乘法结果更新为在第(1+1)次反复的行处理中使用的符号的乘法结果S。

28. 根据权利要求22或23所述的解码方法，其特征在于，

在第1次反复的解码时，作为上述最小值，使用接收LLR的绝对值的最小值。

29. 根据权利要求22或23所述的解码方法，其特征在于，

在每次执行上述列处理步骤时计算后验值，硬判定该后验值，在奇偶检验结果是OK或者反复次数是所规定的最大次数的情况下，作为解码结果输出这时的硬判定值。

30. 根据权利要求10所述的通信装置，其特征在于，

上述行处理单元和上述列处理单元在每次按照规定次数交互进行处理时，进行上述行处理用LLR以及列处理用LLR的更新。

Images