Está en la página 1de 10

METODO JACOBI

En la iteracin de Jacobi, se escoge una matriz Q que es diagonal y cuyos


elementos diagonales son los mismos que los de la matriz A. La matriz Q toma la
forma:

y la ecuacin general (63) se puede escribir como

Qx(k) = (Q-A)x(k-1) + b (65)

Si denominamos R a la matriz A-Q:

la ecuacin (65) se puede reescribir como:

Qx(k) = -Rx(k-1) + b

El producto de la matriz Q por el vector columna x(k) ser un vector columna. De


modo anlogo, el producto de la matriz R por el vector columna x(k-1) ser tambin
un vector columna. La expresin anterior, que es una ecuacin vectorial, se
puede expresar por necuaciones escalares (una para cada componente del vector).
De este modo, podemos escribir, para un elemento i cualquiera y teniendo en
cuenta que se trata de un producto matriz-vector:

Si tenemos en cuenta que en la matriz Q todos los elementos fuera de la diagonal


son cero, en el primer miembro el nico trmino no nulo del sumatorio es el que
contiene el elemento diagonal qii, que es precisamente aii. Ms an, los elementos
de la diagonal de Rson cero, por lo que podemos eliminar el trmino i=j en el
sumatorio del segundo miembro. De acuerdo con lo dicho, la expresin anterior
se puede reescribir como:

de donde despejando xi(k) obtenemos:

que es la expresin que nos proporciona las nuevas componentes del vector x(k) en
funcin de vector anterior x(k-1) en la iteracin de Jacobi. En la figura (14) se
presenta un algoritmo para el mtodo de Jacobi.

Figure: Implementacin del mtodo de Jacobi.


El mtodo de Jacobi se basa en escribir el sistema de ecuaciones en la forma:

(66)

Partimos de una aproximacin inicial para las soluciones al sistema de


ecuaciones y sustituimos estos valores en la ecuacin (66). De esta forma, se
genera una nueva aproximacin a la solucin del sistema, que en determinadas
condiciones, es mejor que la aproximacin inicial. Esta nueva aproximacin se
puede sustituir de nuevo en la parte derecha de la ecuacin (66) y as
sucesivamente hasta obtener la convergencia.
APLICACIN POR EL MTODO DE
JACOBI
19 abril, 2013 de yessicacecilia Aadir a marcadores el enlace permanente.
En amarillo se resaltan los resultados que indican un error aproximado menor o igual al 5%, se consigue en la quinta
iteracin un error aproximado en las tres incgnitas que satisfaga el criterio de paro planteado.

Por lo tanto los resultados aproximados que cumplen con la condicin establecida son:
EJEMPLO DE PROGRAMA

//Libreras necesarias para la implementacin//


#include
#include
#include

//Para leer los datos de un fichero//


double** LeerDatos(char *nombrefichero,int *dimension)
{double **matriz;
int i,j;
FILE *f;
if(f=fopen(nombrefichero,"r"),!f)
{
printf("Problema con la lectura del fichero\n");
return matriz;
}
fscanf(f,"%d\n",&(*dimension));

//Asignacin de memoria dinamica


matriz=(double**)malloc(*dimension*sizeof(double*));
for(i=0;i<*dimension;i++)
{
matriz[i]=(double*)malloc((*dimension)*sizeof(double));
}

//Lectura de elementos de la matriz


for(i=0;i<*dimension;i++) //Recorremos las Filas
{
for(j=0;j<*dimension;j++) //Recorremos las Columnas
{
fscanf(f,"%lf\n",&(matriz[i][j])); //Almacenamos el elemento en la
} //posicin ij.
}
fclose(f);
return matriz;
}

//Procedimiento que muestra una matriz


void muestra(double **matriz,int Tam)
{int i,j;
printf("\n\t");
for(i=0;i
{
for(j=0;j
{
printf("%lf ",matriz[i][j]);
}
printf("\n\t");
}
printf("\n");
}

//Halla el mayor elemento en valor absoluto de la triangular superior


double mayor(double **matriz,int dimension,int *p, int *q)
{int i,j;
double temp;

temp=fabs(matriz[1][0]);*p=1;*q=0;
for(i=2;i
{ //de la diagonal principal y por encima de esta.
for(j=0;j
{ //de la diagonal principal y por encima de esta.
if(fabs(matriz[i][j])>temp)
{
temp=fabs(matriz[i][j]);
*p=i;*q=j;
}
}
}
return temp; //Devolvemos en temp el valor nmerico en valor absoluto ms
} //alto.

//Ejemplo de lo que hace la Funcin Mayor, con una matriz de 3x3


//(1,2,3
// 4,5,-6 //Los elementos de la diagonal Superior seran 2,3 y -6
// 7,8,9) //Al tratarse de valor absoluto el valor que nos dar ser 6.

//Procedimiento de Jacobi
double ** Jacobi(double **autoval,double **autovec,int dim,double tol,int Nmax)
{int p,q,i,j,k,n=0;
double cot,sen,tan,cos,temp,max,ip,iq;
double zero=0.0000000000000001;
//Primero inicializamos la matriz de rotacion a la identidad
for (i=0;i
{
for (j=0;j<=i;j++)
{
if (i==j) autovec[i][j]=1.;
else autovec[i][j]=autovec[j][i]=0.;
}
}

max=mayor(autoval,dim,&p,&q);
while ( (ntol) )
{// Condiciones de parada
cot = (autoval[q][q] - autoval[p][p]) / (2*autoval[p][q]);
if (cot >= zero)
tan = -cot + sqrt(1 + cot * cot);
else
tan = -cot - sqrt(1 + cot *cot);

cos = 1 / sqrt(1+tan*tan);
sen = tan * cos;
for (j=0; j
{ //Vamos rotando la matriz original, hasta que todos
//sus elementos sean ceros,excepto la diagonal
if ((j!=p) && (j!=q))
{
temp = autoval[p][j];
autoval[p][j]=autoval[p][j]*cos - autoval[q][j] * sen;
autoval[j][p]=autoval[p][j];
autoval[q][j] = temp * sen + autoval[q][j] *cos;
autoval[j][q]=autoval[q][j];
}
}//En la diagonal tendremos los autovalores
autoval[q][q] = autoval[q][q] + tan * autoval[p][q];
autoval[p][p] = autoval[p][p] - tan * autoval[p][q];
autoval[p][q] = 0.;
autoval[q][p] = 0.;

for (i=0; i
{ //Vamos calculando la nueva matriz de rotacin
ip=cos*autovec[i][p]+sen*autovec[i][q];
iq=-sen*autovec[i][p]+cos*autovec[i][q];
autovec[i][p]=ip; //Las columnas seran los autovectores
autovec[i][q]=iq;
}
n++;
max=mayor(autoval,dim,&p,&q);
}
//Paramos porque hemos alcanzado el n maximo de iteraciones
if (n==Nmax) printf("Hemos superado el Nmero Mximo\n");
return autoval;
}

int main()
{
double **matautovalores,**matautovectores;
double tol;
int dim,Nmax,i,j;

printf("\n\n ******* METODO DE JACOBI ***********");


printf("\n\n");
printf("Vamos a calcular los autovalores y autovectores de una matriz dada");
printf("\n\n");
printf("Introduzca la tolerancia: \n");scanf("%lf",&tol);
printf("Introduzca el numero maximo de iteraciones (Nmax): \n");scanf("%i",&Nmax);
printf("\n");
matautovalores=LeerDatos("matriz10.dat",&dim);
printf("La dimension de la matriz es %d\n",dim);
printf("\n");

matautovectores=(double**)malloc(dim*sizeof(double*));

printf("La matriz de los autovectores es la primera y la de los autovalores la segunda:\n");


for(i=0;i<dim;i++)
{
matautovectores[i]=(double*)malloc(dim*sizeof(double));
}
Jacobi(matautovalores,matautovectores,dim,tol,Nmax);

muestra(matautovalores,dim);
muestra(matautovectores,dim);

printf("Los autovalores son: \n\n");


for (i=0;i<dim;i++)
{
printf(" <%lf>",matautovalores[i][i]);
}

printf("\n");
printf("\n");
printf("Los autovectores son: \n\n");
for (i=0;i<dim;i++)
{
printf("<");
for (j=0;j<dim;j++)
{
printf("<%lf>",matautovectores[j][i]);
}
printf("> \n");
}
printf("\n");
printf("\n");
printf(" ************** FIN DEL PROGRAMA ************** ");

free (matautovalores);
free(matautovectores);
return 0;
}