1.- CDIGO FUENTE.
Ahora implementamos el mtodo de Jacobi para resolver un sistema de ecuaciones
lineales de n x n aproximando la solucin mediante varias iteraciones sucesivas. El
lenguaje de programacin utilizado ser Java. Para ello, hemos modificado la clase Ma-
triz.java que implementa el mtodo en cuestin, adems de algunos mtodos auxiliares
para que el usuario ingrese las entradas de la matriz desde el teclado y sta se imprima
con un formato entendible, as como tambin unos mtodos para restar vectores y hallar
la norma de un vector, los cuales nos sern tiles a la hora de comprobar el criterio de
detencin. A continuacin se muestra el cdigo fuente:
1
2 import java.util.Scanner;
3
4 class Matriz {
5
6 int filas;
7 int columnas;
8 double m[][];
9
10 public Matriz(double m[][]) {
11 this.m = m;
12 this.filas = m.length;
13 this.columnas = m[0].length;
14
15 }
16
17 public void setFilas(int filas) {
18 this.filas = filas;
19 }
20
21 public void setColumnas(int columnas) {
22 this.columnas = columnas;
23 }
24
25 public int getFilas() {
26 return this.filas;
27 }
28
29 public int getColumnas() {
30 return this.columnas;
31 }
32
33 public void imprimirMatriz() {
34 for (int i = 0; i < m.length; i++) {
35 for (int j = 0; j < m[i].length; j++) {
36
37 if (m[i][j] >= 0) {
38 System.out.printf("\t%s%.2f", " ", m[i][j]);
39 } else {
40 System.out.printf("\t%.2f", m[i][j]);
41 }
1
42
43 }
44 System.out.println("");
45 }
46 System.out.println("");
47 System.out.println("");
48 }
49
50 public void llenarMatriz() {
51 Scanner entrada = new Scanner(System.in);
52 for (int i = 0; i < m.length; i++) {
53 for (int j = 0; j < m[i].length; j++) {
54 System.out.print("Ingrese el elemento [" + (i + 1) +
"," + (j + 1) + "]: ");
55 m[i][j] = entrada.nextInt();
56 }
57 }
58 System.out.println("");
59 }
public void llenarVector(double v[]) {
Scanner entrada = new Scanner(System.in);
for (int i=0; i<v.length; i++) {
System.out.print("Ingrese el elemento ["+(i+1)+"]: ");
v[i] = entrada.nextDouble();
System.out.println("");
public double[] restaVectores(double v1[], double v2[]) {
double resta[] = new double[v1.length];
for(int i=0; i<resta.length; i++) {
resta[i] = v1[i] - v2[i];
return resta;
public double normaVector(double v[]) {
double norma = 0.0;
double suma = 0.0;
2
for(int i=0; i<v.length; i++) {
suma += Math.pow(v[i], 2);
norma = Math.sqrt(suma);
return norma;
/**
* Mtodo que resuelve un sistema de ecuaciones mediante el mtodo de
Jacobi
* @param b - Vector columna b.
* @param epsilon - Criterio de detencin.
* @return - El vector de solucin aproximado.
*/
public double[] jacobi(double b[], double epsilon) {
int N = m.length;
//Inicializamos en vector de aproximacion inicial en 0.0.
double X_Anterior[] = new double[N];
for(int i=0; i<X_Anterior.length; i++) {
X_Anterior[i] = 0.0;
}
double X_Actual[] = new double[N];
for(int i=0; i<X_Actual.length; i++) {
X_Actual[i] = 0.0;
}
double norma = 1.0;
double sumaAux;
int contadorIteraciones = 0;
//Revisa si se cumple con el criterio de detencin
while((norma/normaVector(X_Actual)) >= epsilon) {
sumaAux = 0.0;
contadorIteraciones++;
System.out.println("Iteracin " + contadorIteraciones + ":");
//Actualizamos el vector de aproximacin inicial
for(int i=0; i<X_Anterior.length; i++) {
X_Anterior[i] = X_Actual[i];
}
for(int i=0; i<=N-1; i++) {
for(int j=0; j<=N-1; j++) {
if(j != i) {
sumaAux += m[i][j]*X_Anterior[j];
}
}
X_Actual[i] = (b[i] - sumaAux)/m[i][i];
3
System.out.println("X["+(i+1)+"]: " + X_Actual[i]);
sumaAux = 0.0;
}
System.out.println("");
System.out.println("");
norma = normaVector(restaVectores(X_Actual, X_Anterior));
}
System.out.println("");
return X_Actual;
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("\nIngrese la dimensin de la matriz: ");
int dim = entrada.nextInt();
double A[][] = new double[dim][dim];
Matriz matrix = new Matriz(A);
matrix.llenarMatriz();
System.out.println("\nLa matriz ingresada A es: \n");
matrix.imprimirMatriz();
double b[] = new double[dim];
System.out.println("\nIngrese el vector b: ");
matrix.llenarVector(b);
double epsilon;
System.out.print("\nIngrese el criterio de detencin: ");
epsilon = entrada.nextDouble();
System.out.println("\nAproximando la solucin del sistema de ecua-
ciones "
+ "por el Mtodo de Jacobi... ");
System.out.println("\nEl vector de aproximacin inicial es [0, 0,
0, 0]\n");
matrix.jacobi(b, epsilon);
}
2.- PRUEBA Y EJECUCIN.
Probamos el algoritmo resolviendo el siguiente sistema de ecuaciones de 4x4:
101 12 + 23 + 04 = 6
11 + 112 13 + 34 = 25
21 12 103 14 = 11
01 + 32 13 + 84 = 15
{
4
Durante la ejecucin el programa solicita al usuario ingresar la dimensin del sistema
de ecuaciones (4 en este caso), la matriz de coeficientes, los coeficientes del vector b,
as como tambin el criterio de detencin, que en este caso ser de = 1x10-5:
5
Ahora el programa proceder a ejecutar el algoritmo de Jacobi, resolviendo el sistema
para el vector b. Tomaremos como vector de aproximacin inicial a (0,0,0,0). El pro-
grama imprimir en pantalla todas las iteraciones sucesivas que se vayan obteniendo
hasta llegar al criterio de detencin.
6
7
Observemos que la factorizacin buscada es:
1 1 0 3 1 0 0 0 1 1 0 3
2 1 1 1 2 1 0 0 0 1 1 5
=
3 1 1 2 3 4 1 0 0 0 3 13
1 2 3 1 1 3 0 1 0 0 0 13
8
Con la ltima iteracin, observamos que la solucin aproximada es:
X[1]: 0.999998155430544 1
X[2]: 2.00000292370118 2
X[3]: -1.0000023015887396 -1
X[4]: 1.0000034417997814 1
