ESCUELA POLITÉCNICA NACIONAL

Facultad de Ingeniería en Sistemas

Materia: Algoritmos numéricos

Código: SIC412
Grupo: GR2

Tema: Programa de Método de Jacobi

Grupo de trabajo Número 1

Integrantes: David Moreno

Jacinto Palma
Jorge Zambrano
Nicolás Rosero
Emi Atience
Mario Giler

Fecha de Entrega: 09 de julio del 2017

1. Objetivos
 Elaborar un programa del método de Jacobi de tal manera que me permita dar
solución a un sistema de ecuaciones lineales
 Mediante iteraciones ir dando la solución al sistema de ecuaciones y mostrarlos
por pantalla.
 Definir la exactitud o tolerancia con la que se ira resolviendo sucesivamente
nuestro programa

2. Marco teórico

En la iteración 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 ecuación general (63) se puede escribir como

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

Si denominamos R a la matriz A-Q:

la ecuación (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 análogo, el producto de la matriz R por el vector
columna x(k-1) será también un vector columna. La expresión anterior, que
es una ecuación vectorial, se puede expresar por n ecuaciones 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 término no nulo del
sumatorio es el que contiene el elemento diagonal qii, que es
precisamente aii. Más aún, los elementos de la diagonal de Rson cero, por
lo que podemos eliminar el término i=j en el sumatorio del segundo
miembro. De acuerdo con lo dicho, la expresión anterior se puede
reescribir como:

de donde despejando xi(k) obtenemos:

 El método de Jacobi se basa en escribir el sistema de ecuaciones en la
forma:

(66)

Partimos de una aproximación inicial para las soluciones al sistema de

ecuaciones y sustituimos estos valores en la ecuación (66). De esta forma,
se genera una nueva aproximación a la solución del sistema, que en
determinadas condiciones, es mejor que la aproximación inicial. Esta
nueva aproximación se puede sustituir de nuevo en la parte derecha de la
ecuación (66) y así sucesivamente hasta obtener la convergencia.
3. Diagrama de flujo

4. Desarrollo

Código Fuente:
#include<math.h>
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
/********************************Funcion
Main********************************/
void main()
{
clrscr();
float aux[10],aux1[10],auxx[10],resultado[10],suma,sumat[10],tole[10],
tole1,tolefin[10],tolerancia,w,x1[10],xy[10][10];
int grado,h=0,i=0,j=0;
/*******************************Captura
Datos*******************************/
printf("Grado de la Ecuaci¢n [2 ¢ 3]: ");
scanf("%d",&grado);
for(j=0;j<10;j++)
{
auxx[j]=0;
}
for(i=0;i<grado;i++)
{
printf(" Ingresa la Ecuaci¢n Nø%d ",i+1);
for(j=0;j<grado;j++)
{
printf("X%d%d= ",i+1,j+1);
scanf("%f",&xy[i][j]);
}
printf("Y%d= ",i+1);
scanf("%f",&resultado[i]);
}
/******************************Imprime
Matriz*******************************/
printf(" Las Ecuaciones son... ");
for(i=0;i<grado;i++)
{
for(j=0;j<grado;j++)
{
printf("%.0f[X%d]",xy[i][j],j+1);
if(j==0)
printf("+");
}
printf("=",i+1);
printf("%.0f",resultado[i]);
printf(" ");
}
printf(" La Matriz a Resolver es... ");
for(i=0;i<grado;i++)
{
printf("%c ",179);
for(j=0;j<grado;j++)
{
printf(" %.0f ",xy[i][j],j+1);
}
printf(" %c",179);
printf(" %.0f ",resultado[i]);
printf(" %c ",179);
}
printf(" Ingresa la Exactitud o Tolerancia: ");
scanf("%f",&tolerancia);
for(;;)
{
/*****************Calcula Sumatoria de Despeje de Polinomios****************/
h=0;
do
{
suma=0;
for(i=h;i<h+1;i++)
{
for(j=0;j<grado;j++)
{
if(j!=i)
{
suma+=(xy[i][j]*x1[j])/xy[i][i];
}
}
}
sumat[h]=suma;
h++;
}while(h<grado);
for(i=0,j=grado-1;i<grado;i++,j--)
{
aux[i]=auxx[j];
}
for(i=0;i<grado;i++)
{
for(j=0;j<grado;j++)
{
if(i!=j)
{
auxx[i]=((resultado[i])/xy[i][i])-(sumat[i]);
}
}
}
for(i=0,j=grado-1;i<grado;i++,j--) { x1[i]=auxx[i]; }
for(i=0;i<grado;i++) { tole[i]=0; }
for(i=0,j=grado-1;i<grado;i++,j--) { aux1[i]=auxx[j]; }
for(i=0;i<grado;i++) { tole[i]=aux1[i]-aux[i]; }
/*************************Obtencion de la
Precision**************************/
int k=0;
while(k<grado)
{
for(i=0;i<grado-1;i++)
{
if(tole[i]<tole[i+1])
{
tole1=tole[i];tole[i]=tole[i+1];tole[i+1]=tole1;
}
}
k++;
}
for( j=0;j<grado;j++)
{
tolefin[j]=tole[j];
}
w=tolefin[0];
printf(" ");
for(j=0;j<grado;j++)
{
printf("x%d= %f ",j+1,auxx[j]);
}
if(fabs(w)<=tolerancia)
{
printf(" Resultados en la Iteracion Nø%d ");
for(j=0;j<grado;j++)
{
printf("X%d=%.15f ",j+1,auxx[j]);
}
getch();
break;
}
}
}
Resultados:
 `

5. Conclusiones:
 El método de Jacobi al igual que el método de Gauss Seidel nos sirven para
resolver sistemas de ecuaciones lineales con la ayuda de matrices.
 El método de Jacobi representa una adaptación vectorial de un proceso escalar.
 Los procesos iterativos se detienen cuando entre dos aproximaciones
consecutivas se cumple con determinado error prestablecido.
6. Recomendaciones
 Si el grado de la ecuación es demasiado grande pueda que tarde mucho su
ejecución ya que como es un proceso iterativo continuo se debe ir haciendo paso
a paso y eso tardaría.
 Ir verificando sus procesos iterativos para irse dando cuenta cómo es que el
programa va sacando los vectores y remplazándoos en la formula

7. Biografía:
[1] http://es.slideshare.net/osorio1106/metodos-jacobi-y-gauss-seidel?related=1
[2]http://www.modeladoeningenieria.edu.ar/mei/repositorio/catedras/intIV/practicos/resp/rs
el.pdf