特征值及特征向量 //利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量 //n-矩阵的阶数 //b- 特征值及特征向量 //利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量 //n-矩阵的阶数 //b-
创新互联公司2013年至今，是专业互联网技术服务公司，拥有项目网站设计制作、网站建设网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元革吉做网站,已为上家服务,为革吉各地企业和个人服务,联系电话:18980820575
//数值计算程序-特征值和特征向量
//////////////////////////////////////////////////////////////
//约化对称矩阵为三对角对称矩阵
//利用Householder变换将n阶实对称矩阵约化为对称三对角矩阵
//a-长度为n*n的数组，存放n阶实对称矩阵
//n-矩阵的阶数
//q-长度为n*n的数组，返回时存放Householder变换矩阵
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
void eastrq(double a[],int n,double q[],double b[],double c[]);
//////////////////////////////////////////////////////////////
//求实对称三对角对称矩阵的全部特征值及特征向量
//利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量
//n-矩阵的阶数
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
//q-长度为n*n的数组，若存放单位矩阵，则返回实对称三对角矩阵的特征向量组
// 若存放Householder变换矩阵，则返回实对称矩阵A的特征向量组
//a-长度为n*n的数组，存放n阶实对称矩阵
int ebstq(int n,double b[],double c[],double q[],double eps,int l);
//////////////////////////////////////////////////////////////
//约化实矩阵为赫申伯格(Hessen berg)矩阵
//利用初等相似变换将n阶实矩阵约化为上H矩阵
//a-长度为n*n的数组，存放n阶实矩阵,返回时存放上H矩阵
//n-矩阵的阶数
void echbg(double a[],int n);
//////////////////////////////////////////////////////////////
//求赫申伯格(Hessen berg)矩阵的全部特征值
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//利用带原点位移的双重步QR方法求上H矩阵的全部特征值
//a-长度为n*n的数组，存放上H矩阵
//n-矩阵的阶数
//u-长度为n的数组，返回n个特征值的实部
//v-长度为n的数组，返回n个特征值的虚部
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int edqr(double a[],int n,double u[],double v[],double eps,int jt);
//////////////////////////////////////////////////////////////
//求实对称矩阵的特征值及特征向量的雅格比法
//利用雅格比(Jacobi)方法求实对称矩阵的全部特征值及特征向量
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放实对称矩阵，返回时对角线存放n个特征值
//n-矩阵的阶数
//u-长度为n*n的数组，返回特征向量(按列存储)
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int eejcb(double a[],int n,double v[],double eps,int jt);
//////////////////////////////////////////////////////////////
选自徐世良数值计算程序集(C)
每个程序都加上了适当地注释，陆陆续续干了几个月才整理出来的啊。
今天都给贴出来了
#include "stdio.h"
#include "math.h"
//约化对称矩阵为三对角对称矩阵
//利用Householder变换将n阶实对称矩阵约化为对称三对角矩阵
//a-长度为n*n的数组，存放n阶实对称矩阵
//n-矩阵的阶数
//q-长度为n*n的数组，返回时存放Householder变换矩阵
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
void eastrq(double a[],int n,double q[],double b[],double c[])
{
int i,j,k,u,v;
double h,f,g,h2;
for (i=0; i=n-1; i++)
{
for (j=0; j=n-1; j++)
{
u=i*n+j; q[u]=a[u];
}
}
for (i=n-1; i=1; i--)
{
h=0.0;
if (i1)
{
for (k=0; k=i-1; k++)
{
u=i*n+k;
h=h+q[u]*q[u];
}
}
if (h+1.0==1.0)
{
c[i-1]=0.0;
if (i==1)
{
c[i-1]=q[i*n+i-1];
}
b[i]=0.0;
}
else
{
c[i-1]=sqrt(h);
u=i*n+i-1;
if (q[u]0.0)
{
c[i-1]=-c[i-1];
}
h=h-q[u]*c[i-1];
q[u]=q[u]-c[i-1];
f=0.0;
for (j=0; j=i-1; j++)
{
q[j*n+i]=q[i*n+j]/h;
g=0.0;
for (k=0; k=j; k++)
{
g=g+q[j*n+k]*q[i*n+k];
}
if (j+1=i-1)
{
for (k=j+1; k=i-1; k++)
{
g=g+q[k*n+j]*q[i*n+k];
}
}
c[j-1]=g/h;
f=f+g*q[j*n+i];
}
h2=f/(h+h);
for (j=0; j=i-1; j++)
{
f=q[i*n+j];
g=c[j-1]-h2*f;
c[j-1]=g;
for (k=0; k=j; k++)
{
u=j*n+k;
q[u]=q[u]-f*c[k-1]-g*q[i*n+k];
}
}
b[i]=h;
}
}
b[0]=0.0;
for (i=0; i=n-1; i++)
{
if ((b[i]!=0.0)(i-1=0))
{
for (j=0; j=i-1; j++)
{
g=0.0;
for (k=0; k=i-1; k++)
{
g=g+q[i*n+k]*q[k*n+j];
}
for (k=0; k=i-1; k++)
{
u=k*n+j;
q[u]=q[u]-g*q[k*n+i];
}
}
}
u=i*n+i;
b[i]=q[u];
q[u]=1.0;
if (i-1=0)
{
for (j=0; j=i-1; j++)
{
q[i*n+j]=0.0;
q[j*n+i]=0.0;
}
}
}
return;
//求实对称三对角对称矩阵的全部特征值及特征向量
//利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量
//n-矩阵的阶数
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
//q-长度为n*n的数组，若存放单位矩阵，则返回实对称三对角矩阵的特征向量组
// 若存放Householder变换矩阵，则返回实对称矩阵A的特征向量组
//a-长度为n*n的数组，存放n阶实对称矩阵
int ebstq(int n,double b[],double c[],double q[],double eps,int l)
{
int i,j,k,m,it,u,v;
double d,f,h,g,p,r,e,s;
c[n-1]=0.0;
d=0.0;
f=0.0;
for (j=0; j=n-1; j++)
{
it=0;
h=eps*(fabs(b[j])+fabs(c[j]));
if (hd)
{
d=h;
}
m=j;
while ((m=n-1)(fabs(c[m])d))
{
m=m+1;
}
if (m!=j)
{
do
{
if (it==l)
{
printf("fail\n");
return(-1);
}
it=it+1;
g=b[j];
p=(b[j+1]-g)/(2.0*c[j]);
r=sqrt(p*p+1.0);
if (p=0.0)
{
b[j]=c[j]/(p+r);
}
else
{
b[j]=c[j]/(p-r);
}
h=g-b[j];
for (i=j+1; i=n-1; i++)
{
b[i]=b[i]-h;
}
f=f+h;
p=b[m];
e=1.0;
s=0.0;
for (i=m-1; i=j; i--)
{
g=e*c[i];
h=e*p;
if (fabs(p)=fabs(c[i]))
{
e=c[i]/p;
r=sqrt(e*e+1.0);
c[i+1]=s*p*r;
s=e/r;
e=1.0/r;
}
else
{
e=p/c[i];
r=sqrt(e*e+1.0);
c[i+1]=s*c[i]*r;
s=1.0/r;
e=e/r;
}
p=e*b[i]-s*g;
b[i+1]=h+s*(e*g+s*b[i]);
for (k=0; k=n-1; k++)
{
u=k*n+i+1;
v=u-1;
h=q[u];
q[u]=s*q[v]+e*h;
q[v]=e*q[v]-s*h;
}
}
c[j]=s*p;
b[j]=e*p;
}
while (fabs(c[j])d);
}
b[j]=b[j]+f;
}
for (i=0; i=n-1; i++)
{
k=i; p=b[i];
if (i+1=n-1)
{
j=i+1;
while ((j=n-1)(b[j]=p))
{
k=j;
p=b[j];
j=j+1;
}
}
if (k!=i)
{
b[k]=b[i];
b[i]=p;
for (j=0; j=n-1; j++)
{
u=j*n+i;
v=j*n+k;
p=q[u];
q[u]=q[v];
q[v]=p;
}
}
}
return(1);
}
//约化实矩阵为赫申伯格(Hessen berg)矩阵
//利用初等相似变换将n阶实矩阵约化为上H矩阵
//a-长度为n*n的数组，存放n阶实矩阵,返回时存放上H矩阵
//n-矩阵的阶数
void echbg(double a[],int n)
{ int i,j,k,u,v;
double d,t;
for (k=1; k=n-2; k++)
{
d=0.0;
for (j=k; j=n-1; j++)
{
u=j*n+k-1;
t=a[u];
if (fabs(t)fabs(d))
{
d=t;
i=j;
}
}
if (fabs(d)+1.0!=1.0)
{
if (i!=k)
{
for (j=k-1; j=n-1; j++)
{
u=i*n+j;
v=k*n+j;
t=a[u];
a[u]=a[v];
a[v]=t;
}
for (j=0; j=n-1; j++)
{
u=j*n+i;
v=j*n+k;
t=a[u];
a[u]=a[v];
a[v]=t;
}
}
for (i=k+1; i=n-1; i++)
{
u=i*n+k-1;
t=a[u]/d;
a[u]=0.0;
for (j=k; j=n-1; j++)
{
v=i*n+j;
a[v]=a[v]-t*a[k*n+j];
}
for (j=0; j=n-1; j++)
{
v=j*n+k;
a[v]=a[v]+t*a[j*n+i];
}
}
}
}
return;
}
//求赫申伯格(Hessen berg)矩阵的全部特征值
//利用带原点位移的双重步QR方法求上H矩阵的全部特征值
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放上H矩阵
//n-矩阵的阶数
//u-长度为n的数组，返回n个特征值的实部
//v-长度为n的数组，返回n个特征值的虚部
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int edqr(double a[],int n,double u[],double v[],double eps,int jt)
{
int m,it,i,j,k,l,ii,jj,kk,ll;
double b,c,w,g,xy,p,q,r,x,s,e,f,z,y;
it=0;
m=n;
while (m!=0)
{
l=m-1;
while ((l0)(fabs(a[l*n+l-1])eps*(fabs(a[(l-1)*n+l-1])+fabs(a[l*n+l]))))
{
l=l-1;
}
ii=(m-1)*n+m-1;
jj=(m-1)*n+m-2;
kk=(m-2)*n+m-1;
ll=(m-2)*n+m-2;
if (l==m-1)
{
u[m-1]=a[(m-1)*n+m-1];
v[m-1]=0.0;
m=m-1; it=0;
}
else if (l==m-2)
{
b=-(a[ii]+a[ll]);
c=a[ii]*a[ll]-a[jj]*a[kk];
w=b*b-4.0*c;
y=sqrt(fabs(w));
if (w0.0)
{
xy=1.0;
if (b0.0)
{
xy=-1.0;
}
u[m-1]=(-b-xy*y)/2.0;
u[m-2]=c/u[m-1];
v[m-1]=0.0; v[m-2]=0.0;
}
else
{
u[m-1]=-b/2.0;
u[m-2]=u[m-1];
v[m-1]=y/2.0;
v[m-2]=-v[m-1];
}
m=m-2;
it=0;
}
else
{
if (it=jt)
{
printf("fail\n");
return(-1);
}
it=it+1;
for (j=l+2; j=m-1; j++)
{
a[j*n+j-2]=0.0;
}
for (j=l+3; j=m-1; j++)
{
a[j*n+j-3]=0.0;
}
for (k=l; k=m-2; k++)
{
if (k!=l)
{
p=a[k*n+k-1];
q=a[(k+1)*n+k-1];
r=0.0;
if (k!=m-2)
{
r=a[(k+2)*n+k-1];
}
}
else
{
x=a[ii]+a[ll];
y=a[ll]*a[ii]-a[kk]*a[jj];
ii=l*n+l;
jj=l*n+l+1;
kk=(l+1)*n+l;
ll=(l+1)*n+l+1;
p=a[ii]*(a[ii]-x)+a[jj]*a[kk]+y;
q=a[kk]*(a[ii]+a[ll]-x);
r=a[kk]*a[(l+2)*n+l+1];
}
if ((fabs(p)+fabs(q)+fabs(r))!=0.0)
{
xy=1.0;
if (p0.0)
{
xy=-1.0;
}
s=xy*sqrt(p*p+q*q+r*r);
if (k!=l)
{
a[k*n+k-1]=-s;
}
e=-q/s;
f=-r/s;
x=-p/s;
y=-x-f*r/(p+s);
g=e*r/(p+s);
z=-x-e*q/(p+s);
for (j=k; j=m-1; j++)
{
ii=k*n+j;
jj=(k+1)*n+j;
p=x*a[ii]+e*a[jj];
q=e*a[ii]+y*a[jj];
r=f*a[ii]+g*a[jj];
if (k!=m-2)
{
kk=(k+2)*n+j;
p=p+f*a[kk];
q=q+g*a[kk];
r=r+z*a[kk];
a[kk]=r;
}
a[jj]=q;
a[ii]=p;
}
j=k+3;
if (j=m-1)
{
j=m-1;
}
for (i=l; i=j; i++)
{
ii=i*n+k;
jj=i*n+k+1;
p=x*a[ii]+e*a[jj];
q=e*a[ii]+y*a[jj];
r=f*a[ii]+g*a[jj];
if (k!=m-2)
{
kk=i*n+k+2;
p=p+f*a[kk];
q=q+g*a[kk];
r=r+z*a[kk];
a[kk]=r;
}
a[jj]=q;
a[ii]=p;
}
}
}
}
}
return(1);
}
//求实对称矩阵的特征值及特征向量的雅格比法
//利用雅格比(Jacobi)方法求实对称矩阵的全部特征值及特征向量
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放实对称矩阵，返回时对角线存放n个特征值
//n-矩阵的阶数
//u-长度为n*n的数组，返回特征向量(按列存储)
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int eejcb(double a[],int n,double v[],double eps,int jt)
{
int i,j,p,q,u,w,t,s,l;
double fm,cn,sn,omega,x,y,d;
l=1;
for (i=0; i=n-1; i++)
{
v[i*n+i]=1.0;
for (j=0; j=n-1; j++)
{
if (i!=j)
{
v[i*n+j]=0.0;
}
}
}
while (1==1)
{
fm=0.0;
for (i=0; i=n-1; i++)
{
for (j=0; j=n-1; j++)
{
d=fabs(a[i*n+j]);
if ((i!=j)(dfm))
{
fm=d;
p=i;
q=j;
}
}
}
if (fmeps)
{
return(1);
}
if (ljt)
{
return(-1);
}
l=l+1;
u=p*n+q;
w=p*n+p;
t=q*n+p;
s=q*n+q;
x=-a[u];
y=(a[s]-a[w])/2.0;
omega=x/sqrt(x*x+y*y);
if (y0.0)
{
omega=-omega;
}
sn=1.0+sqrt(1.0-omega*omega);
sn=omega/sqrt(2.0*sn);
cn=sqrt(1.0-sn*sn);
fm=a[w];
a[w]=fm*cn*cn+a[s]*sn*sn+a[u]*omega;
a[s]=fm*sn*sn+a[s]*cn*cn-a[u]*omega;
a[u]=0.0;
a[t]=0.0;
for (j=0; j=n-1; j++)
{
if ((j!=p)(j!=q))
{
u=p*n+j;
w=q*n+j;
fm=a[u];
a[u]=fm*cn+a[w]*sn;
a[w]=-fm*sn+a[w]*cn;
}
}
for (i=0; i=n-1; i++)
{
if ((i!=p)(i!=q))
{
u=i*n+p;
w=i*n+q;
fm=a[u];
a[u]=fm*cn+a[w]*sn;
a[w]=-fm*sn+a[w]*cn;
}
}
for (i=0; i=n-1; i++)
{
u=i*n+p;
w=i*n+q;
fm=v[u];
v[u]=fm*cn+v[w]*sn;
v[w]=-fm*sn+v[w]*cn;
}
}
return(1);
}
C语言并没有封装这类函数，只能自己实现。MATLAB倒是可以直接求。
自己实现的话可以用雅克比迭代法、高斯-赛戴尔迭代法等算法
void Jacobi(int n,float (*a)[7][7],float (*s)[8][8]) //n为矩阵阶数,a为输入矩阵，s为输出矩阵{ int i,j,i1,l,iq,iql,ip; float g,s1,s2,s3,v1,v2,v3,u,st,ct; for(i=0;i=n;i++) { for(j=0;j=i;j++) { if((i-j)==0) (*s)[i][j]=1; else { (*s)[i][j]=0.0; (*s)[j][i]=0.0; } } } g=0; for(i=1;in;i++) { i1=i-1; for(j=0;j=i1;j++) g=g+2*(*a)[i][j]*(*a)[i][j]; } s1=sqrt(g); s2=min/(n)*s1; s3=s1; do { s3=s3/(n); do { l=0; for(iq=1;iqn;iq++) { iql=iq-1; for(ip=0;ip=iql;ip++) { if(fabs((*a)[ip][iq])=s3) { l=1; v1=(*a)[ip][ip]; v2=(*a)[ip][iq]; v3=(*a)[iq][iq]; u=0.5*(v1-v3); if(u==0) g=1; if(fabs(u)=1e-10) g=-(u/fabs(u)*l)*v2/sqrt(v2*v2+u*u); st=g/sqrt(2*(l+sqrt(l-g*g))); ct=sqrt(1-st*st); for(i=0;in;i++) { g=(*a)[i][ip]*ct-(*a)[i][iq]*st; (*a)[i][iq]=(*a)[i][ip]*st+(*a)[i][iq]*ct; (*a)[i][ip]=g; g=(*s)[i][ip]*ct-(*s)[i][iq]*st; (*s)[i][iq]=(*s)[i][ip]*st+(*s)[i][iq]*ct; (*s)[i][ip]=g; } for(i=0;in;i++) { (*a)[ip][i]=(*a)[i][ip]; (*a)[iq][i]=(*a)[i][iq]; } g=2*v2*st*ct; (*a)[ip][ip]=v1*ct*ct+v3*st*st-g; (*a)[iq][iq]=v1*st*st+v3*ct*ct+g; (*a)[ip][iq]=(v1-v3)*st*ct+v2*(ct*ct-st*st); (*a)[iq][ip]=(*a)[ip][iq]; } } } }while(l==1); }while(s3s2); }
重庆分公司
重庆分公司
