信息论与编码原理课程实验.docx

信息论与编码原理课程实验.docx

《信息论与编码原理课程实验.docx》由会员分享，可在线阅读，更多相关《信息论与编码原理课程实验.docx（38页珍藏版）》请在冰豆网上搜索。

信息论与编码原理课程实验

《信息论与编码》

课程实验

湖南大学计算机与通信学院

2010年5月1日

课程实验大纲……………………………………………3

实验一信道容量的迭代算法程序设计………………….4

实验二唯一可译码判决准则……………………………9

实验三Huffman编码方案程序设计…………………15

实验四LZW编码方案程序设计……………………20

实验五Shanoon编码方案程序设计…………………23

实验六循环码的软件编、译码实验…………………….27

实验七BCH码最大似然译码器设计…………………31

课程实验大纲

课程

名称

实验条件和设备

软件包

实验地点

设备名称

实验验收

信息论与

编码原理

C语言软件包

湖南大学

通信工程实验室

计算机

学生在自行计算机上完成实验，在由老师组织验收检查报告，在实验周进行统一时间考核。

VHDL语言

软件包

实验项目内容和要求

序号

实验内容

相应软件与实验要求

实验一

信道容量迭代算法

程序设计

掌握相应实验原理和算法C语言数值

计算程序的设计和调试

实验二

唯一可译码判决准则

程序设计

掌握相应实验原理和算法C语言字符串处理程序的设计和调试

实验三

Huffman编码方案

程序设计

掌握相应实验原理和算法C语言递归

程序的设计调试

实验四

LZW编码方案程序设计

掌握相应实验原理和算法C语言设计和调试中进制转换、数值与字符串之间的

转换等技术

实验五

Shanoon编码方案

程序设计

掌握相应实验原理和算法C语言设计和调试中进制转换、数值与字符串之间的

转换等技术

实验六

（15、7）循环码一般编、译码电路实现研究

掌握相应实验原理和算法工程

实现方法研究

实验七

大数逻辑可译码编、译码算法实现研究

掌握相应实验原理和算法工程

实现方法研究

实验一信道容量的迭代算法程序设计

一、实验目的

（1）进一步熟悉信道容量的迭代算法；

（2）学习如何将复杂的公式转化为程序；

（3）掌握C语言数值计算程序的设计和调试技术。

二、实验要求

（1）已知：

信源符号个数r、信宿符号个数s、信道转移概率矩阵P。

（2）输入：

任意的一个信道转移概率矩阵。

信源符号个数、信宿符号个数和每个具体的转移概率在运行时从键盘输入。

（3）输出：

最佳信源分布P*，信道容量C。

三、信道容量迭代算法

1：

procedureCHANNELCAPACITY（r,s,（

））

2：

initialize:

信源分布

=1/r，相对误差门限

，C=—

3：

repeat

4：

5：

6：

C

7：

until

8：

outputP*=

C

9：

endprocedure

-------------------------------------------------------------------------------------------------------

四、参考代码

/*********************************************************************Author:

HopLee

*Date:

2003.06.25

*Copyright:

GPL

Purpose:

Caculatethecapacityofagivenchannel

*********************************************************************/

#include

#include

#include

#include

#include

#defineDELTA1e-6/*delta,thethreshold*/

intmain（void）

{

registerinti,j;

registerintk;

intr,s;

float*p_i=NULL;

float**p_ji=NULL;

float**phi_ij=ij=NULL;

floatC,C_pre,validate;

float*sum=NULL;

floatp_j;

/*Readthenumberofinputsymbol:

r,

*andthemumberofoutputsymbol:

s*/

fscanf（stdin,"%d",&r）;

fscanf（stdin,"%d",&s）;

/*Allocationmemoryforp_i,p_jiandphi_ij*/

p_i=（float*）calloc（r,sizeof（float））;

p_ji=（float**）calloc（r,sizeof（float））;

for（i=0;i

p_ji[i]=（float*）calloc（s,sizeof（float））;

phi_ij=（float**）calloc（r,sizeof（float*））;

for（i=0;i

phi_ij[i]=（float*）calloc（s,sizeof（float））

/*Readthechanneltransitionprobabilitymatrixp_ji*/

for（i=0;i

for（j=0;j

fscanf（stdin,"%f",&p_ji[i][j]）;

/*Validatetheinputdata*/

for（i=0;i

{

validate=0.0;

for（j=0;j

{

validate+=p_ji[i][j];

}

if（fabs（validate-1.0）>DELTA）

{

fprintf（stdout,"invalidinputdata.\n"）;

exit（-1）;

}

}

fprintf（stdout,”Starting..\n”）;

/*initializethep_iandphi_ij*/

for（i=0;i

{

p_i[i]=1.0/（float）r;

}

/*initializeCanditerationcounter:

k,andtemproryvariable*/

C=-MAXFLOAT;/*MAXFLOATwasdefinedin

k=0;

sum=（float*）calloc（r,sizeof（float））;

/*Startiterate*/

do

{

k++;

/*Calculatephi_ij（k）first*/

for（j=0;j

{

p_j=0.0;

for（i=0;i

p_j+=p_i[i]*p_ji[i][j];

if（fabs（p_j）>=DELTA）

for（i=0;i

phi_ij[i][j]=p_i[i]*phi_ji[i][j]/p_j;

else

for（i=0;i

phi_ij[i][j]=0.0;

}

/*calculatep_i（k+1）then*/

p_j=0.0;

for（i=0;i

{

sum[i]=0.0;

for（j=0;j

{

/*preventdividedbyzero*/

if（fabs（phi_ij[i][j]）>=DELTA）

sum[i]+=p_ji[i][j]*log

（phi_ij[i][j]）/log

（2.0）;

}

sum[i]=pow（2.0,sum[i]）;

p_j+=sum[i];

}

for（i=0;i

{

p_i[i]=sum[i]/p_j;

}

/*andC（k+1）*/

C_pre=C;

C=log

（p_j）/log

（2.0）;

}

while（fabs（C-C_pre）/C>DELTA）;

free（sum）;

sum=NULL;

/*Outputtheresult*/

fprint（stdout,”Theiterationnumberis%d.\n\n”,k）;

fprint（stdout,”Thecapacityofthechannelis%.6fbit/symbol.\n\n”,C）;

fprint（stdout,”Thebestinputprobabilitydistributionis:

\n”）;

for（i=0;i

fprint（stdout,”%.6f”,p_i[i]）;

fprint（stdout,”\n”）;

/*Freethememoryweallocationbeforewithstacksequence*/

for（i=s-1;i>=0;i--）

{

free（phi_ij[i]）;

phi_ij[i]=NULL;

}

free（phi_ij）;

phi_ij=NULL;

for（i=r-1;i>=0;i--）

{

free（p_ji[i]）;

p_ji[i]=NULL;

}

free（p_ji）;

p_ji=NULL;

free（（p_i）;

p_i=NULL;

exit（0）;

}

实验二唯一可译码判决准则

一、实验目的

（1）进一步熟悉唯一可译码判决准则；

（2）掌握C语言字符串处理程序的设计和调试技术。

二、实验要求

（1）已知：

信源符号个数q、码字集合C。

（2）输入：

任意的一个码。

码字个数和每个具体的码字在运行时从键盘输入。

（3）输出：

判决（是唯一可译码/不是唯一可译码）。

三、唯一可译码判决准则算法

1：

procedureUNIQUEDECODABLE（C）

2:

forallW

W

∈Cdo

3:

ifW

是W

的前缀then

4:

将相应的后缀作为一个尾随后缀码放入集合F

中

5:

endif

6:

endfor

7:

loop

8:

forallW

∈Cdo

9:

forallW

∈F

do

10:

ifW

是W

的前缀then

11:

将相应的后缀作为一个尾随后缀码放入集合F

中

12：

elseifW

是W

的前缀then

13:

将相应的后缀作为一个尾随后缀码放入集合F

中

14:

endif

15:

endfor

16:

endfor

17:

F←

18：

if

W

∈F,W

∈Cthen

19:

returnFalse

20:

elseifF中没有出现新的元素then

21:

retureTure

22:

endif

23:

endloop

24:

endprocedure

----------------------------------------------------------------------------

四、参考代码

/********************************************************************

*Author:

ChenMinRu

*Date:

2004.03.16

*Copyright：

GPL

*Purpose：

Findoutwhetheracodeisuniquedecodableornot

****************************************************

#include

#include

#include

#include

#include

#include

#include”ourhdr.h”

intscomp（char**C,intn,int*l）;

voidcompline（char*C,intcline,char*D,

intdline,char**E,int*elinenum）;

intjudge（char**C,intcrow,char**E）;

interow;

intmain（void）

{

registerinti;

intn,l;

int*l_i;

char**C;

/*Readthenumberofinputsymbol:

n*/

fscanf（stdin,”%d”,&n）;

/*Allocationmemoryforl_iand*C[i]*/

l_i=（int*）calloc（n,sizeof（int））;

C=（char**）calloc（n,sizeof（char*））;

/*Readthecodeanditslengthin*/

for（i=0;i

{

fscanf（stdin,”%d”,&l_i[i]）;

l=l_i[i];

C[i]=（char*）calloc（l,sizeof（char））;

fscanf（stdin,”%s”,C[i]）;

}

fprintf（stdout,”Starting…\n\n”）;

i=scomp（C,n,l_i）;

/*Outputtheresult*/

if（i==0）

fprintf（stdout,”Theisuniquedecodable.\n”）;

elseif（i==1）

fprintf（stdout,”TheisNOTuniquedecodable.\n”）;

else

fprintf（stderr,”Error!

\n”）;

/*Freethememoryweallocationbeforewithstacksequeue*/

for（i=n-1;i>=0;i--）

{

free（C[i]）;

}

free（*C）;

free（l_i）;

exit（0）;

}

/*CompareC,DandE*/

intscomp（char**C,intn,int*l）

{

inti;

intcrow,drow;

char**D,**E;

int*dlinenum,*elinenum;

intdrownum;

/*Allocationsoacetodlinenum[i]andelinenum[i]*/

dlinenum=（int*）calloc（n,sizeof（int））;

/*Forthefirsttime,DhasthesamelengthwithC*/

D=（char**）calloc（n,sizeof（char*））;

for（i=0;i

{

dlinenum[i]=l[i];

D[i]=（char*）calloc（l[i],sizeof（char））;

}

drownum=n;

/*Forthefirsttime,letD=C*/

for（i=0;i

strcpy（D[i],C[i]）;

/*CompareCandD*/

compare:

erow=1;

E=（char**）calloc（n,sizeof（char*））;

for（i=0;i

{

E[i]=（char*）calloc（n,sizeof（char））;

}

elinenum=（int*）calloc（n,sizeof（int））;

for（crow=0;crow

{

for（drow=0;drow

{

compline（C[crow],l[crow],D[crow],

dlinenum[drow],E,elinenum）;

}

}

/*CompareDandC*/

for（drow=0;drow

{

for（crow=0;crow

{

compline（D[drow],dlinenum[drow],C[drow],

l[crow],E,elinenum）;

}

}

i=judge（C,crow,E）;

if（i!

=1&&i!

=0）/*LetD=Eandgooncomparing*/

{

drownum=erow–1;

realloc（D,drownum）;

realloc（dlinenum,drownum）;

for（i=drownum–1;i>=0;i--）

{

dlinenum[i]=elinenum[i];

realloc（D[i],dlinenum[i]）;

strcpy（D[i],E[i]）;

free（E[i]）;

}

free（*E）;

free（elinenum）;

gotocompare;

}

else

{

for（i=erow–2;i>=0;i--）

{

free（E[i]）;

}

for（i=drownum–1;i>=0;i--）

{

free（D[i]）;

}

free（*D）;

free（*E）;

free（dlinenum）;

free（elinenum）;

if（i==1）/*It’sNOTuniquedecodable*/

return1;

elseif（i==0）/*It’suniquedecodable*/

return0

}

}

intjudge（char**C,intcrow,char**E）

{

inti,j;

if（ero==1）

return0;/*Stoptheprocessing*/

for（i=0;i

for（j=0;j

if（strcmp（C[i],E[j]）==0）

return1;/*Stoptheprocessing*/

return2;

}

voidcompline（char*C,

intcline,

char*D,

intdline,

char**E,

int*elinenum）

{

if（cline

{

if（strncmp（C,D,cline）==0）

{

/*Reallocate*/

realloc（E,erow）;

realloc（elinenum,erow）;

elinenum[eorw-1]=dline-cline;

realloc（E[erow-1],dline-cline+1）;

/*Copythelastdline-clinecodeintoE*/

strncpy（E[erow-1],&D[cline],dline-cline+1）;

erow++;

}

}

}

实验三Huffman编码方案程序设计

一、实验目的

（1）进一步熟悉Huffman编码过程；

（2）掌握C语言递归程序的设计和调试技术。

二、实验要求

（1）输入：

信源符号个数r、信源的概率分布P；

（2）输出：

每个信源符号对应的Huffman编码的码字。

三、Huffman编码算法描述

1：

procedureHUFFMAN（{s

},{p

}）

2：

ifq==2then

3：

returns

→0，s

→1

4：

else

5：

降序排序{p

}

6：

缩减信源：

创建一个符号s’以取代s

s

其概率为p’=p

+p

7：

递归调用Huffman算法以得到s

，…，s

，s’的编码：

w

，…，w

，w’，相应的

概率分布为p

，…，p

，p’

8：

returns

→w0，…，s

→w

s

→w’0，s

→w’1

9：

endif

10：

endprocedure

-------------------------------------------------------------------------------

四、参考代码

/********************************************************************

*Author:

ChenMinRu

*Date:

2004.03.15

*Copyright:

GPL

*Purpose:

Huffmanrecursivecodingalgorithm

********************************************************************/

#include

#include

#include

#include

#defineDELTA1.0e-6

voidsort（double*,char**,int*,int）;

voidcode（double*,char**,int*,int）;

int

main（void）

{

float*p_i,*p;

floatsum;

floattemp;

char**c;

int*idx;

intq;

inti;

/*Readthenumberofsourcesymbolin*