信息论实验-Hamming编码

实验目的

加深理解Hamming(7,4)码的编码方法和抗干扰性能。通过编程实现Hamming
(7,4)码的便拿码算法，进一步掌握按位二进制加法的实现原理。

实验要求

输入：长度为4的任意二进制序列
输出：输入数据经Hamming(7,4)编码器编码之后，通过作业3(2)二元对称信道模拟器
(错误概率为0.1)传输后，再经过Hamming(7,4)译码器输出得到新宿的长度为4的二进制
序列。

实验原理

基本定义

1. 定义1：设一个D元(N, L)线性分组码的生成矩阵G,校验矩阵H。则H是一个D源(N,N-L)
   线性分组码的生成矩阵，G是此码的一个校验矩阵。称这两个码互为对偶码。

   1. 定义2：一个N维向量的Hamming重量为它的对应位置值不等于0的位数。

   2. 定义3：两个N维向量的Hamming距离定义为他们的对应位置不同的位数。

   3. 信道的输入为码字U，信道的输出为向量Y，称向量$e=Y-U$为差错向量。

   4. 设H是校验矩阵，对于N维行向量t，记$s=tH^T$为向量t的伴随式。

基本定理

1. 定理1：设信道输入码字U，输出向量为Y，差错向量$e=Y-U$，则e的伴随式等于Y的
   伴随式。

   1. 定理2：设输出向量为Y，并计算出了Y的伴随式$s=YH^T$。则此时所有可能的差错向量
      恰好就是任何一个可能的差错向量加上全体码字。即此时所有可能的差错向量恰好就是方程
      $s=tH^T$的任何一个固定解t加上全体码字。

实现原理

二元码和非二元码都存在汉明码，我们以二元汉明码为例。汉明码不是一个码，而是一类码，
凄惨数具有下列形式

$$(n,k)=(2^m-1,2^m-m-1)$$
其中m为正整数。例如当$m=3$时，就得到了(7,4)汉明码。汉明码的校验矩阵具有特殊的性质
，对于二元码，它的$2^m-1$个列包含了除0之外的所有$n-k=m$维向量。通过观察可以发现，
校验矩阵$H$中任何两个列矢量是线性独立的，但是可以找到3个列矢量之和为0.所以对于所有的
汉明码器最小汉明距离$d_{min}=3$。

由于汉明码的校验矩阵 包含了所有非零m维向量，通过编排列矢量的顺序可以很容易地得到具有
式

$$H=[-P^T|I_{n-k}]$$ 形式的系统汉明码的校验矩阵$H$，进而可以得到系统汉明码的生成
矩阵。例如观察如下校验矩阵，其列矢量为(001),(010),(011),(100),(101),(110),(111)。
$$\ A = \begin{bmatrix} 1 & 0 & 0 & 0 & 1 & 0 & 1 \\ 0 & 1 & 0 & 0 & 1 & 1 & 1 \\ 0 & 0 & 1 & 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 1 & 0 & 1 & 1 \end{bmatrix}=[I_4|P] \ $$

算法实现

汉明码的定义是一个线性分组码，它的最小Hamming距离为3,能纠正全部一位错误。
而且编码译码都非常简单，接收矢量的伴随式等于校验矩阵H中与出错位对应的矢之和。
\subsection{算法步骤}
1. 通过线性变换由信源端产生的L长的信号x生成信道编码后的N长的信号Y，

$$Y=XG$$ 其中G是生成矩阵。
2. 将步骤1产生的信号Y通过二元对称信道，二元对称信道需设置错误概率。通过
二元对称信道的信号计为$Y'$
3.由公式$s=Y'H^T$计算出$Y'$的伴随式s，根据定理可知信道输出$Y'$的伴随式
和差错向量e的伴随式相等，将$Y'$产生的伴随式当作差错向量e产生的伴随式进一步
找到可能的差错向量。
4. 在以s为伴随式的全体“可能的差错向量中”，取一个Hamming重量最小的向量作为
s的培集首，记为$e(s)$。
5. 计算通过信道前的信号Y，$U=Y'-e(s)$。
6. 输出线性U的线性逆变换即为经过信道传输并经过Hamming编码译码的信号。

算法程序实现

主函数部分依次执行各个模块的功能

 int  main()
{
  int n;
  cout<<"请输入四位信息位"<<endl;
  for(n=0;n<4;n++)
  {
    cin>>message[n];
  }
  creat_code(message,G);
  cout<<"发送的七位代码为："<<endl;
  for(n=0;n<7;n++)
  {
    cout<<send[n]<<" ";
  }
  cout<<endl;
  cout<<"请输入收到的七位代码"<<endl;
  for(n=0;n<7;n++)
  {
    cin>>Y[n];
  }
  syndrome(Y,H);
  cout<<"校正子为："<<endl;
  for(n=0;n<3;n++)
  {
    cout<<S[n]<<" ";
  }
  cout<<endl;
  comp(S,H) ;
  cout<<"纠正子为："<<endl;
  for(n=0;n<7;n++)
  {
    cout<<e[n]<<" ";
  }
  cout<<endl;
  correct_code(Y,e);
  cout<<"接收到的七位码为："<<endl;
  for(n=0;n<7;n++)
  {
    cout<<C[n]<<" ";
  }
  cout<<endl << endl;

  cout<<"接收到的四位信息为："<<endl;
  for(n=0;n<4;n++)
  {
    cout<<get_code[n]<<" ";
  }
  cout<<endl;
  return 0;
}

可以看到主函数一次执行的功能包括：

1. 输入四位的原始信息

2. 产生7位信道编码

3. 7位编码经过二元对称信道后的编码

4. 生成矫正子和纠正子(也就是原理中对应的差错编码)

5. 输出接收到的7位编码

6. 输出解码后的4位信息码

　核心函数包括

1. void creat_code(int array1[4],int array2[4][7])
   该函数用来生成7位的信道编码，输入的参数是4位的信源符号和4×7的生成矩阵。

void creat_code(int array1[4],int array2[4][7]) //生成七位发送的代码
{
  int i,j,m=0;
  for(j=0;j<7;j++)
    {
      for(i=0;i<4;i++)
      {
        m=(array1[i]*array2[i][j])^m;
      }
    send[j]=m;
    m=0;
    }
}

1. void syndrome(int array[7],int array1[3][7])

   该函数用来计算矫正子也就是原理中提到的输出向量的伴随式，
   输入参数1是经过二元对称信道的信号编码，参数2是校验矩阵。
   “`
   void syndrome(int array[7],int array1[3][7]) //得出矫正子S
   {
   int k=0,a,b;
   for(a=0;a<3;a++)
   {
   for(b=0;b<7;b++)
   {
   k=k^(array1[a][b]*array[b]);
   }
   S[a]=k;
   k=0;
   }
   }

 3. void comp(int array1[3],int array[3][7])

  该函数用来生成纠正子，也就是我们原理那部分的差错向量e，输入参数1是函数2产生的伴随式，
  输入参数2是校验矩阵。
  ```
  void comp(int array1[3],int array[3][7]) //得出纠正子e
{
  int i=0,j=0,m=1,p;
  while(m)
  {//j=j+1;
          if((array1[0]==array[0][i])&&(array1[1]==array[1][i])&&(array1[2]==array[2][i]))
          {
            m=0;
            row=j;
            for(p=0;p<7;p++)
              {
                if(p==row)e[p]=1;else e[p]=0;
              }
          }
            else
            {
              j=j+1;i++;
              if(i==7)
              {
                for(p=0;p<7;p++)
                {
                  e[p]=0;
                }
                m=0;
      }
      }
      }
}

1. void correct_code(int array3[7],int array4[7])
   该函数的功能是得出更正后的码字,输入参数1是校验矩阵，输入参数2是最小Hamming距离的差错向量。

void correct_code(int array3[7],int array4[7]) //得出正确的码字
{
  int z;
  for(z=0;z<7;z++)
  {
    C[z]=Y[z]^e[z];
  }
  for(z=0;z<4;z++)
  {
    get_code[z]=C[z+3];
  }
}

我们测试的输入向量为[1 0 1 0],生成的7位编码为[0 0 1 1 0 1 0],假设通过二元对称信道后的编码
为[0 0 1 1 0 1 1]即最后一位发生错误，那么得到的伴随式为[1 0 1],最小Hamming距离对应的
差错向量为[0 0 0 0 0 0 1],所以得出接收到的7位编码为[0 0 1 1 0 1 0],最后的出纠正后的
编码为[1 0 1 0],和我们输入的向量是一样的，所以按此方法可以做到信道编码的纠错。

总结

此次实验通过模拟Hamming编码译码器的功能，从原理上分析了信道编码的基本流程，和相应的实现方法，
以Hamming编码译码器为例展开讨论，深化了我们对信道编码和信道传输的理解。