信 息 论 课 程 设计

信息论课程设计

设计题目:费诺与算术编码

学号: 2013211885

姓名: 张留柱

班级: 信息安全13-1

指导老师: 苏兆平

时间: 2015.9.28

一、问题描述

1.理解和掌握费诺编码和算术编码的基本原理。

2.编程实现费诺编码和算术编码的基本流程。

3. 了解费诺编码和算术编码的优缺点。

4. 实现费诺编码和算术编码的

二、基本要求

Fano编码

基本要求：对任意输入的字符串序列进行3元fano编码，给出编

码结果、编码效率；并实现相应的译码操作。

算术编码

基本要求：对任意的字符串序列进行自适应算术编码，并设计相应

的译码

三、算法思想

费诺编码

编码原理

首先,将信源符号以概率递减的次序排列进来，将排列好的信源符号划分为 3大组，使每组的概率和近于相同,并各赋于一个三元码符号”0”1”

和“2”.然后，将每一大组的信源符号再分成三组，使同一组的三个个小组的概率和近于相同，并又分别赋予一个三元元码符号。依次下去，直至每一个小组只剩下一个信源符号为止。这样，信源符号所对应的码符号序列则为编得的码字。

译码原理

1.根据译码的输入符号串,先读取第一个字符，然后在编码表里找寻，看是否有与之匹配的

2.如果有，则输出这个编码对应的字符.然后继续下一个译码字符的匹配，重复1直到所有的输入译码串都匹配完，否则进入4

3.如果没有，则译码的字符串加入下一个译码字符，组成新的需要译码的字符串然后重复 1

4.译码输入有误。

算术编码

编码原理

统计输入的字符串，各个字符的概率，以及他们的累计概率，然后开始对输入的编码字符串进行算术编码。

F(S a k)=F(S)+P(S)F(a k)

P(S a k)=P(S)p(a k)

F(S)为字符串的累计概率，F(a k)为单独的字符累计概率，p(a k)字符的统计概率算出最后的输入字符串的累计概率，然后转化为2进制。码长

L=┎log(1/p(s)) ┑取码长的2进制码，若后面还有则码进一个2进制的1 译码原理

记录编码时，字符串的编码区间，然后对应的找到即可了

四、测试数据

3元费诺

算术编码

五、模块划分

费诺编码（函数顺序基于CODE。。。）

1.类数组：

2.code（sz,total,begin,end）编码函数，字符是在类数组SZ里，然后是此区间的总概率TOTAL。....begin 和end 需要编码的字符串的区间，编码后的会码会记录在sz.s里

3.计算编码效率的sz的各个字符的以及编码的长度的计算，int j 是字符的种类的个

数此函数会输出编码的效率

4.译码函数对输入的字符进行基于编码的译码，若输入的字符在编码时有问题则返回信息，因为一个译码完成后继续对下一个字符的译码时，把译码字符串S1清空失败，所以建立了S2来记录空的S1,以便再次译码时的清空操作

5.统计函数对输入字符串ch的统计统计种类到M，字符串的字符记录在a[i].zifu

相应的概率到a[i].probability 对字符串CH的每个字符进行判断是否已经记录了这个字符依据情况，修改概率

6.编码函数的重复调用. p为循环的概率除的基数BUFFER数组里储存的是需要编码的区间上限下限因为一些变量在统计函数里所以编码函数的调用用在了统计函数里

算术编码

1.类数组：

2统计函数对输入字符串ch的统计统计种类到M，字符串的字符记录在a[i].zifu

相应的概率到a[i].probability 对字符串CH的每个字符进行判断是否已经记录了这个字符依据情况，修改概率

累计概率类数组的a[i].f里

3编码函数根据书上面的公式算的累计概率，不是很精确，取得是LONG DOUBLE 精度的不过是从第一个字符顺着算的，不是递归

编码函数的完善，码长后还有尾数，则进1，（因为是2进制1，所以采用出后往前1变0继续,知道有个0变1则停止）

4 译码函数因为在编码的时候把各个字符串的累计概率储存起来了，译码做了个判断就行了。。。

六、源程序

费诺

////////////////////////////3元费诺

#include

#include

// CLASS数组字符概率

//#include

#include

using namespace std;

class shuzu{ //建立类数组用来储存统计输入的字符的各个属性

public :

shuzu(){

probability=0.0;};

~shuzu(){};

char zifu;

double probability;

string s; //各个字符对应的编码

} ;

shuzu a[100];

int q=0,p=1,m=0; //m是记录字符的类别

int buffer[10][1]; //buffer数组记录每次的区间的起点和终点

////////////////////编码

void code(shuzu sz[],double total,int begin,int end)//初end =m-1 { int buffer1=0,buffer2=0;

double newtotal= total/3;

shuzu temp[2];

temp[0].probability=0.0;

temp[1].probability=0.0;

if (begin>=end) return ;

if((end-begin)<=2){ //小于3个时

sz[begin].s+="0";

sz[begin+1].s+="1";

if((end-begin)==2) sz[end].s+="2";

Q

}

else{

for(int i=begin;i

temp[0].probability=temp[0].probability+sz[i].probability;

temp[1].probability=temp[0].probability+sz[i+1].probability;

if

(fabs(temp[0].probability-newtotal)<=fabs(temp[1].probability-newtotal ) ){ //比较前后的量哪个更加接近此区间的1/3

for(int j=begin;j<=i;j++) //满足的编码0

{ sz[j].s+="0"; buffer1=i+1;}

buffer[q][0]=begin; //buffer数组储存区间的上下限

buffer[q][1]=i+1;

q++ ;

break; //编码0的结束后要跳出循环不然temp的概率会继续累加，影响下面的判断

}

}

for( i=buffer1;i

temp[0].probability=temp[0].probability+sz[i].probability;

temp[1].probability=temp[0].probability+sz[i+1].probability;

if

(fabs(temp[0].probability-2.0*newtotal)<=fabs(temp[1].probability-2.0*n ewtotal) ){ //同上

for(int j=buffer1;j<=i;j++)

{ sz[j].s+="1"; buffer2=i+1;}

buffer[q][0]=buffer1;

buffer[q][1]=i+1;

q++ ;

break;

}

}

for(int j=buffer2;j<=end;j++)

{sz[j].s+="2";}

buffer[q][0]=buffer2;

buffer[q][1]=end+1;

q++ ;

}

}

//////////////////////////////////////效率

void xiaolv(shuzu sz[],int j){ // j即为所有字符的种类

double temp3=0.0,temp4=0.0,temp5;

for (int i=0;i

temp3=sz[i].probability*sz[i].s.length()+temp3;

temp4=-sz[i].probability*log(sz[i].probability)/log(3)+temp4;

}

/////////////////////调试量

// cout<

//cout<

temp5 =temp4/temp3;

cout<<"编码效率"<

return ;

};

//////////////////////////////////////译码

void yima(string str){

string s1,s2;int biaozhi;

s2=s1;//S2保存初始量便于清空

// cout<

for(int i=0;i

s1=s1+str[i]; biaozhi=0; // s1用来记录需要当前匹配的

for(int j=0;j<=m;j++){

if (s1==a[j].s)

{cout<

// s1清0后再次插入出现BUG --

}

}

if(biaozhi==0)

{cout<<"译码输入有错误"<

}

////////对信源的输入字符的统计

void tongji(){

int length,n=0;

string ch; //输入的字符串

cout<<"请输入字符串"<

cin>>ch ;

length = ch.length();

// cout<

// shuzu a[100];

shuzu temp2[3]; //做缓存

for(int i=0;i

int biaozi=0;

for (int j=0;j

if(ch[i]==a[j].zifu){

a[j].probability=a[j].probability + 1.0/length;

biaozi =1; // 设置匹配到的标志

}

}

if(biaozi==0){

a[m].zifu=ch[i] ;

a[m].probability=1.0/length;

m++;

}

}

//排序

for(int j=0;j

for(int i=m-1;i>j;i--){

if(a[i].probability>a[i-1].probability)

{ temp2[0]=a[i];

a[i]=a[i-1];

a[i-1]=temp2[0];

}

}

}

code(a,1.0,0,m-1); ////////p为循环的概率除的基数BUFFER数组里储存的是需要编码的区间上限下限

for (i=0;i<=q+2;i++){

if(((i+1)%3)==0) {p++;} //3次则p+1

code(a,1.0/(3*p),buffer[i][0],buffer[i][1]-1);

}

xiaolv(a,m);

cout<

for(int x =0;x

{cout<

void main()

{ string aq;//需要译码的字符串

tongji();

cout<<"输入译码的字符串"<

cin>>aq;

yima(aq);

}

算术编码

// 算术编码

#include

#include

#include

#include

using namespace std;

class shuzu{

public :

shuzu(){

probability=0.0;};

~shuzu(){};

char zifu;

double probability;

double f ;//累计概率

} ;

shuzu a[100]; //信源的序列

int m=0; //信源的个数

string ch; //输入的字符串

char code[20] ; //码序列

int l ;// 码长

string ym[20];

long double ym2[20][1];

void tongji(){

int length,n=0;

cout<<"请输入字符串"<

cin>>ch ;

length = ch.length();

// cout<

shuzu temp[1];

for(int i=0;i

int biaozi=0;

for (int j=0;j

if(ch[i]==a[j].zifu){

a[j].probability=a[j].probability + 1.0/length;

biaozi =1; // 设置匹配到的标志

}

}

if(biaozi==0){

a[m].zifu=ch[i] ;

a[m].probability=1.0/length;

m++;

}

}

a[0].f=0.0;//a[1].f=a[0].probability;/////////////取得是累计概率下限

for(i=1;i

a[i].f=a[i-1].f+a[i-1].probability;

}

};

////////////////////////////////////////////译码

void yima(long double c,shuzu sz[]){

long double temp1,temp2=0.0,min;

int length =ch.length (),z;

/* for (int i=0;i

temp1=c-f1;

for(int j=0;j

temp2=q;

q=temp2; //保存下界

temp2=(q+sz[j].probability)*p;

cout<

cout<

if(temp1<=temp2)

{ ym[i]=sz[j].zifu;break; }

}

f1=f1+q;

p=temp2*p;

}*/

// temp1=c-ym2[0][0];

for(int i=1;i

min=c-ym2[i][0];

temp2=c-ym[i+1][0];

if(min>temp2)

z=i+1; //标记

}

cout<<"译码"<

}

/////////////////////////////////////编码

void bianma(shuzu sz[],string s){

int temp;

int j,length=s.length();

long double p=1.0,f=0.0;

for(int i=0;i

for(j=0;j

if(s[i]==sz[j].zifu) break;}

f=f+p*sz[j].f;////////////累计函数

p=p*sz[j].probability; /// 区间

ym2[i][0]=f;

ym2[i][1]=p;

for(int q=0;q<=i;q++)

ym[i]=ym[i]+s[q];

}

///////cout<

cout<<"累计函数"<<"\t"<

cout<<"区间"<<"\t"<

l=ceil(-log(p)/log(2)); //码长

yima(f,a);////////////////////////////译码

// int cd=0;

// cout<

for(i=0;i

f=f*2;

temp=int(f);

f=f-temp;

if(temp==0)

code[i]='0';

else code[i]='1';

}

// cout<

// code[i++]='\0';

// cout<

if(f!=0){ //有尾数则进1

for(i=l-1;i>=0;i--){

if(code[i]=='0')

{code[i]='1';break;}

else code[i]='0';

}

}

cout<<"码序列"<<"\t"<

void main()

{ tongji();

bianma(a,ch);

cout<<"字符"<<"累计概率"<

cout<

}