Cómo escribir un programa en lenguaje C para encontrar los valores propios y vectores propios de una matriz simétrica
///////////////////////////////// /// /////////////////////////////
//Aproximación de matriz simétrica a matriz simétrica tridiagonal
/Uso de la transformada de Householder para aproximar matrices simétricas reales de enésimo orden a matrices tridiagonales simétricas
/a- matriz de longitud n*n que contiene matrices simétricas reales de enésimo orden
/n -números de los órdenes de las matrices
/n-números de los órdenes de las matrices.
//n- El orden de la matriz
//q- Matriz de longitud n*n, la matriz de transformación de Householder se guarda cuando se devuelve
//b- Matriz de longitud n, los elementos diagonales principales de la matriz tridiagonal se guardan cuando se devuelve
//c- Una matriz de longitud n, cuando se devuelve, se guardan los primeros n-1 elementos del elemento subdiagonal
void eastrq(double a[], int n , doble q[], doble b[], doble c[]);
/////////////////////////////// /////////// ///////////////////////
// Encuentra todos los valores propios y vectores propios de una matriz real simétrica tridiagonalmente simétrica
//Calcular todos los valores propios y vectores propios usando el método QR variacional
//n-El orden de la matriz
//b-Una matriz de longitud n, devuelta Elementos diagonales principales de la matriz tridiagonal
//c- Una matriz de longitud n, devuelve una matriz que contiene los elementos subdiagonales del primer n-1 elementos
//q- Una matriz de longitud n*n, si contiene el conjunto de vectores propios tridiagonales simétricos reales de la matriz simétrica real A, entonces devuelve la matriz que contiene la matriz identidad
// Si contiene el conjunto de vectores propios tridiagonales simétricos reales de la matriz simétrica real A, la matriz de transformación de Scheder, devuelve el conjunto de vectores propios de la matriz simétrica real A
//a- una matriz de longitud n*n , que contiene una matriz simétrica real de orden n
int ebstq(int n,double b[],double c[],double q[ ],double eps,int l);
/////////////// /////////////////////////////////// ////////////////
//Utiliza la transformación de similitud elemental para aproximar la matriz de números reales a la matriz de Heisenberg
//Utiliza el transformación de similitud elemental para aproximar la matriz de números reales de orden n a la matriz H superior
// Matriz con longitud n*n, guardar la matriz real de orden n, regresar para guardar la matriz H superior
//matriz de orden n
void echbg(double a[],int n );
//////////////// / //////////////////////////// ///////////////////// /
// Encuentra todos los valores propios de la matriz de Hesenberg
// Un valor de retorno menor que 0 significa que la iteración excede jt pero aún no ha alcanzado la precisión
// Un valor de retorno mayor que 0 significa retorno normal
// Utilice el método QR de dos pasos para encontrar todos los valores propios de la matriz H superior. /a-Una matriz de longitud n*n, incluida la matriz H superior
//n-El orden de la matriz
//u-Una matriz de longitud n, que devuelve n Parte real de valores propios
//v-Una matriz de longitud n, devuelve la parte imaginaria de n valores propios
//v-Una matriz de longitud n, devuelve n valores propios parte imaginaria del valor propio
//u-Una matriz de longitud n, devuelve la parte real de n valores propios
//v-Una matriz de longitud n, devuelve n El imaginario parte del valor propio
//u-Una matriz de longitud n, devuelve la parte real de n valores propios
//v-Una matriz de longitud n, devuelve n La parte imaginaria del valor propio. Devuelve la parte imaginaria de n valores propios
/eps- Requisitos de precisión de control
//jt- Variable entera que controla el número máximo de iteraciones
int edqr( doble a[],int n,doble u[],doble v[],doble eps,int jt);
// //////////////// / ///////////////////////////////////////////////////p>
// Usa el método de Jacobi para encontrar los valores propios y vectores propios de la matriz simétrica
// Usa el método de Jacobi para encontrar todos los valores propios y vectores propios de la matriz simétrica
// Retorno Un valor menor que 0 significa que el número de iteraciones ha excedido jt y aún no ha alcanzado el requisito de precisión
// Un valor de retorno mayor que 0 significa retorno normal
//Una matriz de longitud n*n, que contiene una matriz de simetría real, devuelve la diagonal de n valores propios
// Orden de la n-matriz
//u Matriz de longitud n*n, devuelve el vector propio (almacenado en Columna)
//eps- Requisitos de precisión de control
//jt- Variable entera, controla el número máximo de iteraciones
int eejcb(doble a[],int n,doble v[],doble eps,int jt);
////// ///////// /////////////// ////////////////////////////////////
Seleccionado del<
Cada programa tiene los comentarios correctos, ¡me tomó meses armarlo! Llevo unos meses haciendo esto.
Lanzado hoy
#include "stdio.h"
#include "math.h"
// Utilice la transformación de cabeza de familia para Las matrices simétricas son matrices simétricas aproximadamente tridiagonales
//Matrices simétricas reales de enésimo orden aproximadas a matrices tridiagonales simétricas
/a- Matriz de longitud n*n que contiene matrices simétricas reales de enésimo orden Una matriz de longitud n*n, devuelve la matriz después de la transformación de Householder
//b- Una matriz de longitud n, devuelve los elementos diagonales principales de la matriz tridiagonal
//. c- Una matriz de longitud n, devuelve los elementos subdiagonales de los primeros n-1 elementos
void eastrq(double a[],int n,double q[],double b[ ],double c[])
{
int i,j,k,u,v;
doble h,f,g,h2;
para (i=0; i<=n-1; i++)
{
para (j=0; j<=n-1; j++ )
{
u=i*n+j; q[u]=a[u]
}
}
}
}
para (i=n-1; i>=1; i--)
{
p>
h=0.0;
si (i>1)
{
para (k=0; k<=i- 1; k++)
{
u=i*n+k
h= h+q[u]*q[u]; p>
}
}
si (h+1.0==1.0)
{
c[i-1 ]= 0.0;
si (i==1)
{
c[i-1]=q[i*n+i-1]
}
b[i]=0.0
}
si no
{
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;
p>
g=0.0
para (k=0; k<=j; k++)
{
g=g+q[ j*n+k]*q[i*n+k];
}
si (j+1<=i-1)
{
para (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]
}
}<; /p>
}
b[i]=h
}
}
b[0]=0.0 ;
for (i=0; i<=n-1; i++)
{
si ((b[i]! = 0.0)&&(i-1 >=0))
{
para (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];
}
{
g = g+q[i*n+k]*q [k*n+j];
}
{
f ((b[i]! = 0.
para (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;
si (i-1>=0)
{
para (j=0; j<=i-1; j++)
{
q[i*n+j ]=0.0
q[j*n+i]=0.0
}
}
}
Retorno;
// Encuentra todos los valores propios y características de una matriz tridiagonalmente simétrica simétrica real Vectores
//Calcular todos los valores propios y vectores propios usando el método QR variacional
//n- El orden de la matriz
//b- El length es una matriz de n, devuelve los elementos diagonales principales de la matriz tridiagonal
//c- Una matriz de longitud n, devuelve los elementos subdiagonales de los primeros n-1 elementos
//q- Una matriz de longitud n*n, si contiene el conjunto de vectores propios tridiagonales simétricos reales de la matriz simétrica real A, entonces devuelve la matriz que contiene la matriz identidad
// Si contiene la matriz de transformación de Hausched, devuelve el conjunto de vectores propios de la matriz simétrica real A
// Una matriz de longitud n*n, que contiene la matriz simétrica real de orden n
int ebstq( int n,doble b[],doble c[],doble q[ ],doble eps,int l)
{
int i,j,k,m,it, u,v;
doble d,f,h,g,p,r,e,s
c[n-1]=0.0; >d=0.0;
f=0.0;
para (j=0; j<=n-1; j++)
{
es=0;
h=eps*(fabs(b[j
])+fabs(c[j]));
si (h>d)
{
d=h; >}
m=j;
mientras ((m<=n-1)&&(fabs(c[m])>d))
{
m=m+1
}
si (m!=j)
{
hacer
{
if (it==l)
{
printf("falla\n")
retorno(-1);
}
it=it+1; /p>
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); p>}
else.
else
{
b[j]=c[j]/(p-r); /p>
}
h=g-b[j];
para (i=j+1; i<=n-1; i++)
{
b[i]=b[i]-h
}
f=f+h
p=b[m];
e=1.0;
s=0.0;
para (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; =1.0/r;
}
más.
más
{
e=p/c [i];
r=sqrt(e*e +1.0);
c[i+1]=s*c[i]*r; p>s=1.0/r;
e=e/r
}
p=e*b[i]-s*g; /p>
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; [u];
q[u]=s*q[v]+e*h;
q[v]=e*q[v]-s*h;
}
}
c[j]=s*p
b[j]=e*p; p>
p>
}
mientras (fabs(c[j])>d
}
b[j]; =b[j] +f;
}
para (i=0; i<=n-1; i ++)
{
k=i; p=b[i];
si (i+1<=n-1)
{
j =i+1;
mientras ((j<=n-1)&&(b[j]<=p))
{
k=j;
p=b[j];
j=j+1;
}
si (k!=i)
{
b[k]=b[i]
; b[i]=p;
para (j=0; j<=n-1; j++)
{
u=j*n+ i
v=j*n+k
p=q[u]
q[u] =q[v]; >
p=q[u];
q[u] =q[v]
p>
q[v]=p; >
}
}
}
return(1
p>
}
;//Utilice la transformación de similitud original para aproximar la matriz real de orden n a la matriz H superior
//a Una matriz de longitud n*n guarda la matriz de números reales de orden n, regresa y guarda la matriz H superior
//Número de matriz de orden N
void echbg(double a[],int n)
{ int i, j,k ,u,v;
doble d,t;
para (k=1; k<=n-2; k++)
{
d=0.0;
for (j=k; j& lt;=n-1; j++)
{
u =j* n+k-1;
t=a[u];
si (fabs(t)>fabs(d))
{
d=t;
i=j
}
}
}
if (fabs(d)+1.0!=1.0)
{
if (i!=k)
{
para (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; /p>
}
{
para (i!
para (j=0; j<=n-1; j++ )
{
u=j*n+i;
v=j*n+k
t=a[u];
a[u]=a[v];
a[v]=t
}
}
}
para (i=k+1; i<=n-1; i++)
{
u=i *n+ k-1;
t=a[u]/d;
a[u]= 0,0
para (j=k; j<= n-1; j++)
{
v=i*n+j
a[v]=a[v]-t *a[ k*n+j];
}
para (j=0; j<=n-1; j++)
{
v=j*n+k;
a[v]=a[v]+t*a[j*n+i]
}
}
}
}
}
}
//// /// // Encuentra todos los valores propios de la matriz de Hesenberg.
// Utilice el método QR de dos pasos con movimiento de origen para encontrar todos los valores propios de la matriz H superior
// El valor de retorno menor que 0 significa que la precisión no puede ser logrado incluso después de iteraciones jt
//// Un valor de retorno mayor que 0 significa retorno normal
//a- una matriz de longitud n*n, que contiene la matriz H superior
/ /n-El número de pasos de la matriz
//n-El número de pasos de la matriz
////un rango
/u-Una matriz de longitud n, devuelve la parte real de n valores propios
/v- una matriz de longitud n, devuelve la parte imaginaria de n valores propios
/eps- requisitos de precisión de control
/jt- Variable entera, controla el número máximo de iteraciones
int edqr(double a[], int n, double u[], doble v[], doble eps, int jt)
{
int m,it,i,j,k,l,ii,jj,kk,ll;
doble b,c,w,g,xy ,p,q,r,x,s,e,f,z,y
it=0; >m=n;
mientras ( m! =0)
{
l=m-1
mientras (( l>0)&&(fabs(a[l*n+ l-1])>eps*(fabs(a[(l-1)*n+ l-1])+fabs(a[l*n+l]) ))))
{
l=m-1
it=0
m=n; >
mientras (m!
{
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
si (l==m-1)
{
u[m-1]=a[(m -1)*n+m-1];
v[m-1]=0.0; -1; es=0;
}
si no (l==m-2)
{
b=-(a[ii]+a[ll ]);
c=a[ii]*a[ll]-a[jj]*a[kk]; p>w=b*b-4.0*c;
y=sqrt(fabs(w));
if (w>0.0)
{
xy=1.0;
si (w>0.0)
xy=1.0
p>
si (b) <0.0)
{
xy=-1.0
}
u[ii] *a[ll]-a[; jj]*a[kk];
w=b*b-4.
u[m-1]=(-b-xy *y)/2.0; p>
u[m-2]=c/u[m-1];
v[m-1 ] = 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
{
Si (it&g
t;=jt)
{
printf("falla\n");
return(-1);
it=it+1;
for (j=l+2; j<=m-1; j++)
{
a[j*n+j-2]=0.0;
}
para (j=l+3; j<=m-1; j++)
{
a[j*n+j-3]=0.0
}
para (k=l; k<=m -2; k++)
{
si (k!=l)
{
p=a[k*n+ k -1];
q=a[(k+1)*n+k- 1];
r=0.0; =m-2)
{
r=a[(k+2)*n+k-1]; p>}
}
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>
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;
si (p<0.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); /p>
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]; ];
p>
si (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;
}
} p>
mientras (1==1)
{
fm=0.0;
para (i=0; i<=n-1; i++)
{
para (j=0 ; j<=n-1; j++)
{
d=fabs(a[i* n+j]);
>si ((i!=j)&&(d>fm))
{
fm=d
p=i;
q=j
}
}
}
}
si (fm< eps)
{
if (fm { return(1); } if (l>jt) { 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 (y<0.0) { omega=-omega; } 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; } } } para (i=0; i<= n- 1; i++) { u=i*n+p w=i*n+q; =v[u]; v[u]=fm*cn+v[w]*sn; v[w]=-fm*sn+v[w] *cn; } } } retorno(1); >