数值算法求矩阵的最大特征值的幂法.docx
《数值算法求矩阵的最大特征值的幂法.docx》由会员分享，可在线阅读，更多相关《数值算法求矩阵的最大特征值的幂法.docx（12页珍藏版）》请在冰豆网上搜索。
数值算法求矩阵的最大特征值的幂法
[数值算法]求矩阵的最大特征值的幂法.
对于工程计算而言，矩阵的特征值和特征向量都是相当重要和常见的数据，这里给出的幂法是一种常见的求解方法，用的是迭代的思想。
符号说明:
1A为待求的矩阵，
2Uk，Vk为迭代用的列向量。
3最后的最大特征值maxLamda由最后一次的max（Uk）-----求Uk中的绝对值最大的元素的绝对值.所决定。
而maxLamda所对应的特征向量由最后一次迭代的Vk所决定.
主要的想法就是先选一个不为0的初始向量U0!
=0，然后按下面的式子迭代。
U0=V0!
=0
Do
{
Uk=AVk-1
Vk=Uk/max（Uk）
}while（abs（max（Uk）-max（Uk-1））>=e）好了，就这样,更多的细节请去参考相关的数值算法书籍.
在贴出程序之前，先对一部分我新增加的实用函数进行说明：
如:
voidtwoDArrMemApply（Type***inArr,introwNum,intcolNum）
{
inti=0;/*iteratorvaule*/
（*inArr）=（Type**）malloc（sizeof（Type*）*rowNum）;
for（i=0;i（*inArr）[i]=（Type*）malloc（sizeof（Type）*colNum）;
assertF（*inArr!
=NULL,"intwoDArrMemApply,inArratlastisnull\n"）;
}
voidtwoDArrMemFree（Type***inArr,introwNum）
{
inti=0;/*iteratorvalue*/
assertF（（*inArr）!
=NULL,"in2darrmemfree,inarrisnull\n"）;
for（i=0;ifree（（*inArr）[i]）;
free（（*inArr））;
}
这两个函数的作用相信大家一看就明白，是实现二维指针的申请内存和释放内存的，这样，以后再主程序里的工作量就会小多了。
还有，我在写一些程序段的时候对待外部传进的指针采用如下处理手段（纯C条件下）
除非这个函数有特殊的作用，如申请内存，或要读入外部文本内容到二维指针等。
其余的情况，一律不对外部指针进行任何申请或释放内存的处理。
对于要保护数据的外部传入指针，则在函数内部再做一个局部指针，在函数结尾释放.
对局部指针的操作，也仅限于赋值，而绝对不要用外部传入针指去指向它（即赋一个临时区的地址给外部的指针变量），这当然是错误的。
好了，下面是程序段:
/*formaxlamdaresolve*/
TypepowerMethodForLamda（Type**matrixA,intsize,char*outputFileName）
{
TypemaxLamda;
Type*listV;
Type*listU;
FILE*outputFile;/*theoutputFileforthedataoutput*/
TypepreMax;/*atweendata*/
floate=（float）;/*theprecisecontroller*/
TypetmpData;/*tempdataforprogram*/
inti=0;/*iteratortimes*/
intiteratorNum=0;/*iteratornumber*/
/*assertion*/
assertF（matrixA!
=NULL,"inpowerMethodForlamda,matrixAisnull\n"）;
assertF（outputFileName!
=NULL,"inreadList,listFileNameisnull\n"）;
/*openfile*/
assertF（（outputFile=fopen（outputFileName,"wb"））!
=NULL,"outputfileopenerror\n"）;
/*memapply*/
listArrMemApply（&listV,size）;
listArrMemApply（&listU,size）;
/*initialization*/
for（i=0;i{
listV[i]=0;
listU[i]=0;
}
listV[size-1]=1;
listU[size-1]=1;
/*coreprogram*/
fprintf（outputFile,"iteratorTimemaxUk\r\n"）;
do
{
assertF（listNotZero（listU,size）,"inthecoreofpowerMethodForLamdalistUisNULL\n"）;
assertF（listNotZero（listV,size）,"inthecoreofpowerMethodForLamdalistVisNULL\n"）;
preMax=maxAbsValInList（listU,size）;
matirxBy2DWith1DCol（matrixA,listV,listU,size,size）;
tmpData=1/maxAbsValInList（listU,size）;
numByList（tmpData,listU,listV,size）;
fprintf（outputFile,"%-16d%-16f\r\n",iteratorNum,maxAbsValInList（listU,size））;
}
while（fabs（preMax-maxAbsValInList（listU,size））>=e）;
fprintf（outputFile,"charactsticvectoris:
\r\n"）;
outputListArrFloat（listV,0,size,outputFile）;
/*EndoftheCoreProgram*/
maxLamda=maxAbsValInList（listU,size）;
fprintf（outputFile,"themaxlamdais:
\r\n%f.\r\n",maxLamda）;
/*memfree*/
free（listV）;
free（listU）;
/*closethefile*/
fclose（outputFile）;
returnmaxLamda;
}
/*相应的辅助函数*/
/*matirxBy2DWith1DCol一个n*n的矩阵和一个n*1的列向量作乘法*/
voidmatirxBy2DWith1DCol（Type**matrixA,Type*matrixListIn,Type*matrixListAns,introwNum,intmNum）
{
/*variabledeclare*/
inti,k;/*iteratornumber*/
Typesum;
/*assertion*/
assertF（matrixA!
=NULL,"intwoMatrixBymatrixAisnull\n"）;
assertF（matrixListIn!
=NULL,"intwoMatrixBymatrixBisnull\n"）;
assertF（matrixListAns!
=NULL,"intwoMatrixBymatrixAnsisnull\n"）;
/*coreprogram*/
for（i=0;i{
sum=0;
for（k=0;ksum+=matrixA[i][k]*matrixListIn[k];
matrixListAns[i]=sum;
}
}
/*求一个一维向量中绝对值的最大值*/
TypemaxAbsValInList（Type*inList,intlen）
{
inti;/*iteratornum*/
TypemaxData;
assertF（inList!
=NULL,"inmaxValInList,inListisNULL\n"）;
maxData=（Type）fabs（inList[0]）;
for（i=1;iif（fabs（inList[i]）>maxData）maxData=（Type）fabs（inList[i]）;
returnmaxData;
}
/*testprogram*/
/*maxLamdaresolvetestprogram*/
#include""
#include""
#include""
#include""
#include<>
#include<>
#include<>
#include<>
char*inFileName="";
/*
inputdataspecification
row,col;
.;
,,,
,,,
an1,an2,...;
}
*/
char*outFileName="";
#defineDEBUG1
voidmain（intargc,char*argv[]）
{
FILE*inputFile;/*inputfile*/
FILE*outputFile;/*outputfile*/
doublestartTime,endTime,tweenTime;/*timecallopsedinfo*/
introwNum,colNum;
Type**wArr;
TypemaxLamda;
intn;/*arrdeminisionforsqurematrix*/
/*defaultinputfileopen*/
if（argc>1）strcpy（inFileName,argv[1]）;
assertF（（inputFile=fopen（inFileName,"rb"））!
=NULL,"inputfileerror"）;
printf（"inputfileopensuccess\n"）;
/*defaultoutpoutfileopen*/
if（argc>2）strcpy（outFileName,argv[2]）;
assertF（（outputFile=fopen（outFileName,"wb"））!
=NULL,"outputfileerror"）;
printf（"outputfileopensuccess\n"）;
/*Thisfunction,automaticallyfullfillthetaskof
applythememforthe2dpointers.Perfect,right:
）*/
read2DArrFloat（&wArr,&rowNum,&colNum,""）;
#ifDEBUG
printf（"\n*******startoftestprogram******\n"）;
printf（"nowisrunnig,pleasewait...\n"）;
startTime=（double）clock（）/（double）CLOCKS_PER_SEC;
/******************Coreprogramcode*************/
/*arguprepare*/
assertF（colNum==rowNum,"intestcolNum!
=rowNum"）;
n=rowNum;/*getthesizeofsquarematrix*/
maxLamda=powerMethodForLamda（wArr,n,""）;
printf（"themaxlamdais:
%f.\r\n",maxLamda）;
fprintf（outputFile,"themaxlamdais:
%f.\r\n",maxLamda）;
/******************EndofCoreprogram**********/
endTime=（double）clock（）/（double）CLOCKS_PER_SEC;
tweenTime=endTime-startTime;/*Getthetimecollapsed*/
/*Timecollapsedoutput*/
printf（"thecollapsedtimeinthisalgorithmimplementis:
%f\n",tweenTime）;
fprintf（outputFile,"thecollapsedtimeinthisalgorithmimplementis:
%f\r\n",tweenTime）;
printf（"\n*******endoftestprogram******\n"）;
#endif
twoDArrMemFree（&wArr,rowNum）;
printf（"programendsuccessfully,\nyouhavetopreessanykeytocleanthebufferareatooutput,otherwise,youwiilnotgetthetotalanswer.\n"）;
getchar（）;/*ScreenDelayControl*/
return;
}
测试结果:
输入：
3,3;
2,3,2;
10,3,4;
3,6,1;
输出:
iteratorTimemaxUk
0
0
0
0
0
0
0
0
0
0
charactsticvectoris:
,;
themaxlamdais:
.
PS:
最近在数模班里，也的确看到了别的专业一些对程序和算法在理解上比较强能力的人，虽然他们可以告诉你解决了某个问题，但你看一眼他写的程序，充斥在你眼里的，都是大量的“蛮力”算法，像10个层甚至更高层的for循环比比皆是，基本上就是针对这个问题的特型算法。
当他们把这个问题这样“解决”的时候，他们会认为事情已经OK了，而我却还不得不承认自己没想出一个比较好的通用算法。
呵呵~~~随他去呢，反正我水平本来就不高，但作为一个计算机专业的学生而言，保证算法的通用性和函数的模块性，是首要的任务，如果这个程序里要用什么10个层的循环来做，我还不如不写。
还有一些自认为数学感觉好的人，认为经典算法的源程序都在那儿了，自己只要能将它在程序中实现，就了事了.算法在他们的视线里，更多的是只算一种公式，甚至可以不必去了解它的细节.这样的观点和想法，在我这个计算机专业的人看来，同样是不可取的。
路漫漫其修远兮,吾将上下而求索.
升级会员 