第一组信道容量的迭代算法.docx

第一组信道容量的迭代算法.docx

《第一组信道容量的迭代算法.docx》由会员分享，可在线阅读，更多相关《第一组信道容量的迭代算法.docx（23页珍藏版）》请在冰豆网上搜索。

第一组信道容量的迭代算法

信道容量的迭代算法

组长：

20090710107胡思宇

组员：

20090710611蒙晶

20090710902樊璐

20090710904傅予

20090710928郑国盛

20090711022夏阳

20090711201卜红丽

信道容量的迭代算法

一、指数迭代

原理：

由平均互信息的定义可知：

所以得到平均互信息与输入分布概率和反向传递概率的关系：

其中：

输入概率：

反向传递概率：

假设输入概率给定，令偏导数为零得到最优的反向传递概率为：

假设反向传递概率给定，令偏导数为零得到最优输入概率：

其中：

★在反向传递概率与输入概率中每次固定一个求另一个的最佳值，如此交替迭代从而逼近平均互信息的最大值，即信道容量。

程序流程图：

计算结果示例：

示例一：

示例说明：

所用矩阵为题目给定的第一个矩阵，精度：

1E-6

第一个返回值是每一步得到的信道容量，第二个返回值是最后的输入概率分布，第三个返回值是每一步的用时，第四个返回值是运算的步长（迭代次数）

示例二：

（节选部分结果）

......

示例说明：

所用矩阵为题目给定的第二个矩阵

其余同示例一

示例三：

（C语言版矩阵一）

示例四（C语言版矩阵二）

二、线性乘法迭代

原理：

以输入作为唯一变量，以泰勒级数展开可得到平均互信息关于输入概率分布的增量公式：

进一步转化得：

其中：

增加前的平均互信息：

增加后的平均互信息：

增加前的信息量偏差：

增加前后的输入概率：

信道转移概率：

输出概率：

输入概率的增量：

★选取合适的

使

单调递增从而逼近最大值即信道容量。

的实际选取方法如下：

设

取

其中：

程序流程图：

计算结果示例：

示例一：

示例说明：

使用题目给定矩阵一

精度：

1E-6

C:

各步计算出的信道容量的逼近值；P_x:

最终的输入概率分布

T_a:

个不计算的时间;T_d:

总迭代次数

示例二：

示例说明：

使用题目给定矩阵一

其余同示例一

三、算法对比

时间复杂度：

按时间收敛：

矩阵一：

矩阵二：

按步长收敛：

矩阵一

矩阵二：

结论：

从迭代次数的角度来说，简单的传递矩阵迭代后两种差距并不明显，一旦传递矩阵的规模扩大，线性乘法迭代达到计算精度所用的次数明显比指数迭代少。

但是从计算速度的角度来说，指数迭代比线性乘法迭代更快达到要求。

空间复杂度：

两个算法的空间复杂度差别不大。

四、附件（源程序及其它）

指数迭代：

%=========================================================

%FileName:

（文件名：

）

%II2CC.m

%Author:

（作者：

你改动了文件就在后面加名字）

%FuYu（傅予）

%SamHu（hsy19891228@）（胡思宇）

%FunctionTable:

（函数表：

）

%[]=II2CC（）（函数声明）

%{

%Function:

ApproachChannelCapacity

%（功能：

逼近信道容量）

%Method:

IndexIteration

%（方法：

指数迭代）

%}

%

%TestEnvironment:

（测试环境：

）

%Win7/Matlab7.8.0/7.10.0（傅予/胡思宇）

%ModificationHistory:

（文件修改的记录：

做了啥改动啥时候）

%Builtin2011/12/16by傅予；

%Modifiedin2011/12/18by胡思宇；

%=========================================================

function[IL,p,T_a,n]=II2CC（p_yx,Tol）

%====I/OTable====（输入输出表）

%Input:

%--p_yx:

ProbabilityofChannelTransition（信道转移矩阵）

%--Tol:

Tolerance（误差容限）

%Output:

%--IL:

ApproximatevalueofChannelCapacity（近似结果）

%--p:

ProbabilityofInputVector（输入向量）

%--T_a:

EvaluationofTimeconsumption（算法时间）

%--n:

Steps（迭代次数/步长）

%==EndofI/OTable==

[N,M]=size（p_yx）;

s=zeros（N,1）;

d=zeros（N,1）;

p=zeros（N,1）;

q=zeros（M,1）;

a=zeros（N,1）;

T_a=zeros（2,1）;

%DefaultTolerance:

1E-6（误差容限默认为1*10^-6）

ifnargin<2

Tol=1E-6;

end

fori=1:

N%各行概率累加求和

s（i）=0;

forj=1:

M

s（i）=s（i）+p_yx（i,j）;

end

end

fori=1:

N%判断是否符合概率分布

if（s（i）<=0.999999||s（i）>=1.000001）

error（'不符合概率分布'）

end

end

fori=1:

N

p（i）=1.0/N;%取初始概率为均匀分布

end

TickOn=tic;

forj=1:

M%计算q（j）

q（j）=0;

fori=1:

N

q（j）=q（j）+p（i）*p_yx（i,j）;

end

end

fori=1:

N%计算a（i）

d（i）=0;

forj=1:

M

if（p_yx（i,j）==0）

d（i）=d（i）+0;

else

d（i）=d（i）+p_yx（i,j）*log（p_yx（i,j）/q（j））;

end

end

a（i）=exp（d（i））;

end

u=0;

fori=1:

N%计算u

u=u+p（i）*a（i）;

end

IL=log2（u）;%计算IL

IU=log2（max（a））;%计算IU

n=1;

while（（IU-IL）>=Tol）%迭代计算

T_a（n）=toc（TickOn）;

fori=1:

N

p（i）=p（i）*a（i）/u;%重新赋值p（i）

end

forj=1:

M%计算q（j）

q（j）=0;

fori=1:

N

q（j）=q（j）+p（i）*p_yx（i,j）;

end

end

fori=1:

N%计算a（i）

d（i）=0;

forj=1:

M

if（p_yx（i,j）==0）

d（i）=d（i）+0;

else

d（i）=d（i）+p_yx（i,j）*log（p_yx（i,j）/q（j））;

end

end

a（i）=exp（d（i））;

end

u=0;

fori=1:

N%计算u

u=u+p（i）*a（i）;

end

IL（n）=log2（u）;%计算IL

IU=log2（max（a））;%计算IU

n=n+1;

end

T_a（n）=toc（TickOn）;

end

指数迭代（C语言版）：

#include

#include

#defineMAX100

doubleCalculate_a（intk,doublepa[]）;

doubleCalculate_C1（doublepa[],doublea[]）;

doubleCalculate_C2（doublea[]）;

intr,s;

doublepba[MAX][MAX];

voidmain（）

{

inti,j;

doubleC1,C2,E;

doublea[MAX],pa[MAX];

printf（“请输入精度：

\n”）;

scanf（“%lf”,&E）;

printf（"请输入信源符号个数r:

\n"）;

scanf（"%d",&r）;

printf（"请输入信宿符号个数s:

\n"）;

scanf（"%d",&s）;

printf（"请输入信源P[ai]:

\n"）;

for（i=0;i

scanf（"%lf",&pa[i]）;

printf（"请输入信道转移概率矩阵P[bj][ai]:

\n"）;

for（i=0;i

for（j=0;j

scanf（"%lf",&pba[i][j]）;

do

{

for（i=0;i

a[i]=Calculate_a（i,pa）;

C1=Calculate_C1（pa,a）;

C2=Calculate_C2（a）;

if（C2-C1>=E）

{

doublesum=0;

for（i=0;i

sum+=pa[i]*a[i];

for（i=0;i

pa[i]=pa[i]*a[i]/sum;

}

else

{

printf（"最佳信源概率:

\n"）;

for（i=0;i

printf（"%10.9lf\n",pa[i]）;

}

}while（C2-C1>=E）;

printf（"信道容量为:

%16.15lf\n",C1/log

（2））;

}

doubleCalculate_a（intk,doublepa[]）

{

inti,j;

doubletemp,sum2=0;

for（j=0;j

{

doublesum1=0;

for（i=0;i

{

sum1+=pa[i]*pba[i][j];

}

temp=pba[k][j]/sum1;

temp=log（temp）;

sum2+=pba[k][j]*temp;

}

returnexp（sum2）;

}

doubleCalculate_C1（doublepa[],doublea[]）

{

inti;

doublesum=0;

for（i=0;i

sum+=pa[i]*a[i];

returnlog（sum）;

}

doubleCalculate_C2（doublea[]）

{

inti;

doublemax=a[0];

for（i=0;i

if（max

returnlog（max）;

}

程序说明：

doubleCalculate_a（intk,doublepa[]）定义计算a[i]函数

doubleCalculate_C1（doublepa[],doublea[]）定义计算

函数

doubleCalculate_C2（doublea[]）定义计算

函数

线性乘法迭代：

%========================================================