Universidad Nacional Autónoma de México
Facultad de Estudios Superiores Aragón
Métodos Numéricos
Gauss-Seidel y Jacobi
Ingeniería en Computación
MÉTODOS ITERATIVOS – “GAUSS-
SEIDEL” Y “JACOBI”
Profesor: ING. RAFAEL GONZALEZ BETANCOURT
Alumnos:
MARCO ANTONIO SANDOVAL FORTIS
JAEL MENDOZA ROMERO
MOISES DE JESÚS GARCÍA MARTÍNEZ
Grupo: 1357 (2024-I) Proyecto: No. 1
“DOCUMENTACIÓN”: (GAUSS-SEIDEL)
Descripción General del Programa
El programa resuelve sistemas de ecuaciones lineales utilizando el Método
de Gauss-Seidel. Este método se utiliza para encontrar las soluciones
aproximadas de sistemas de ecuaciones lineales.
Explicación del Código
El código está escrito en Java y consta de las siguientes secciones:
1. Inicialización de variables y entrada de datos:
· Se utiliza la clase “Scanner” para obtener la entrada del
usuario.
· Se inicializan variables para almacenar valores iniciales y
errores.
· Se crea una matriz bidimensional
(“ArrayList<ArrayList<Float>> matriz”) para almacenar los
coeficientes del sistema de ecuaciones.
2. Entrada de datos de la matriz:
· Se solicita al usuario el número de ecuaciones en el sistema y
se llena la matriz con los coeficientes proporcionados por el
usuario.
3. Mostrar la matriz ingresada por el usuario:
· La matriz ingresada por el usuario se muestra en formato
tabular.
4. Implementación del Método de Gauss-Seidel:
· Se utiliza un bucle “while” para iterar y calcular los valores de
“x”, “y” y “z”.
· Se utilizan fórmulas específicas para calcular los valores de
“x1”,” y1” y “z1” basados en los valores anteriores y los
coeficientes de la matriz.
· Se calculan los errores relativos porcentuales “ex”, “ey” y
“ez” para cada variable en cada iteración.
· Los valores de “x1”, “y1” y “z1” junto con los errores relativos
se imprimen en cada iteración.
5. Criterio de terminación:
· Se comprueba si los errores relativos son suficientemente
pequeños para detener el bucle y finalizar el cálculo.
“CÓDIGO”: (GAUSS-SEIDEL)
public static void main(String[] args) {
Scanner sc = new Scanner([Link]);
float x1=0, y1=0, z1=0, x2=0, y2=0, z2=0, ex=0,ey=0, ez=0;
int ecu=0;
ArrayList<ArrayList<Float>> matriz = new ArrayList<>();
[Link]("Esta aplicacion resuelve sistemas de ecuaciones
lineales 3x3 por el metodo de gauss-seidel");
[Link]("(La matriz debe ser dominante, cuadrada y no
debe temer elementos nulos)");
ecu = 3;
[Link]("");
for (int i = 0; i < ecu; i++) {
[Link](new ArrayList<>());
for (int j = 0; j <= ecu; j++) {
[Link]("Ingresa el coeficiente de [%d][%d]:", i, j);
[Link](i).add([Link]());
}
}
[Link]("\nTu matriz es:");
[Link]("");
for (ArrayList<Float> fila : matriz) {
[Link]("|");
for (float elemento : fila) {
[Link]("%-5.0f|",elemento);
}
[Link]("%n-------------------------%n%n");
}
int contador = 0;
boolean n = true;
while (n) {
x2=x1;
x1=
((-([Link](0).get(1))*(y1))-([Link](0).get(2))*(z1)+([Link](0).ge
t(3)))/([Link](0).get(0));
ex=((x1-x2)/x1)*100;
y2=y1;
y1=
(-([Link](1).get(0))*(x1)-([Link](1).get(2))*(z1)+([Link](1).get(
3)))/([Link](1).get(1));
ey=((y1-y2)/y1)*100;
z2=z1;
z1=
(-([Link](2).get(0))*(x1)-([Link](2).get(1))*(y1)+([Link](2).get(
3)))/([Link](2).get(2));
ez=((z1-z2)/z1)*100;
[Link]("%d x: %f y: %f z: %f%n", contador, x1, y1,
z1);
[Link]("%d ex: %f ey: %f ez: %f%n%n", contador,ex,
ey, ez);
contador++;
if((int) (ex*10000) == 0){
if((int) (ey*10000) == 0){
if((int) (ez*10000) == 0){
n = false;
}
}
}
}
}
“DOCUMENTACIÓN”: (JACOBI)
Descripción General del Programa
Este programa resuelve sistemas de ecuaciones lineales mediante el
Método de Jacobi. El Método de Jacobi es un método iterativo utilizado
para encontrar soluciones aproximadas a sistemas de ecuaciones lineales.
Explicación del Código
El código está escrito en Java y se divide en varias secciones:
1. Entrada de datos:
· Se utiliza la clase “Scanner” para obtener la entrada del
usuario.
· Se solicita al usuario que ingrese la matriz de coeficientes “A”,
el vector de términos independientes “b”, y un vector inicial
opcional “x0”. También se solicita la tolerancia y el número
máximo de iteraciones.
2. Implementación del Método de Jacobi:
· La función “jacobi()” resuelve el sistema de ecuaciones
usando el método iterativo de Jacobi.
· Utiliza un bucle “for” para realizar las iteraciones del método.
· Calcula los nuevos valores de “x” en cada iteración basándose
en los valores previos de “x”.
· Verifica si se alcanza la convergencia, es decir, si la norma del
vector de la diferencia entre el vector actual y el vector previo
es menor que la tolerancia especificada. Si se cumple, se
devuelve la solución.
3. Funciones de apoyo:
· “norm()”: Calcula la norma euclidiana de un vector.
· “subtract()”: Realiza la resta elemento por elemento de dos
vectores.
· “readMatrix()”: Lee una matriz de coeficientes proporcionada
por el usuario.
· “readVector()”: Lee un vector proporcionado por el usuario.
· “printVector()”: Imprime un vector en consola.
4. Flujo Principal del Programa:
· El flujo principal del programa se encuentra en la función
“main()”.
· Se solicitan los datos necesarios para resolver el sistema de
ecuaciones usando el Método de Jacobi.
· Llama a la función “jacobi()” y muestra la solución obtenida.
Consideraciones adicionales
· El método de Jacobi puede no converger para todas las matrices de
coeficientes y condiciones iniciales. Por lo tanto, es importante
tener en cuenta el comportamiento del método en diferentes
situaciones y matrices.
· La eficacia del método depende de la matriz de coeficientes y puede
requerir un número variable de iteraciones para alcanzar la
convergencia.
Este código es una implementación básica del Método de Jacobi en Java
para resolver sistemas de ecuaciones lineales de manera iterativa.
“CÓDIGO”: (JACOBI)
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
// Solicitar al usuario ingresar la matriz de coeficientes A
[Link]("Ingrese la matriz de coeficientes A:");
double[][] A = readMatrix(scanner);
// Solicitar al usuario ingresar el vector de términos independientes b
[Link]("Ingrese el vector de términos independientes b:");
double[] b = readVector(scanner, [Link]);
// Solicitar al usuario ingresar el vector inicial x0 (opcional)
[Link]("Ingrese el vector inicial x0 (opcional):");
double[] x0 = readVector(scanner, [Link]);
// Especificar la tolerancia y el número máximo de iteraciones
(opcional)
[Link]("Ingrese la tolerancia:");
double tol = [Link]();
[Link]("Ingrese el número máximo de iteraciones:");
int maxIter = [Link]();
// Resolver el sistema de ecuaciones utilizando el método de Jacobi
double[] solution = jacobi(A, b, x0, tol, maxIter);
// Imprimir la solución
[Link]("Solución:");
printVector(solution);
}
private static double[] jacobi(double[][] A, double[] b, double[] x0,
double tol, int maxIter) {
int n = [Link];
double[] x = (x0 != null) ? [Link]() : new double[n];
double[] xPrev = [Link]();
for (int k = 0; k < maxIter; k++) {
for (int i = 0; i < n; i++) {
double sigma = 0.0;
for (int j = 0; j < n; j++) {
if (j != i) {
sigma += A[i][j] * xPrev[j];
}
}
x[i] = (b[i] - sigma) / A[i][i];
}
if (norm(subtract(x, xPrev)) < tol) {
[Link]("Convergió en " + (k + 1) + " iteraciones.");
return x;
}
xPrev = [Link]();
}
[Link]("No convergió en el número máximo de
iteraciones.");
return x;
}
private static double norm(double[] vector) {
double sum = 0.0;
for (double val : vector) {
sum += val * val;
}
return [Link](sum);
}
private static double[] subtract(double[] a, double[] b) {
int n = [Link];
double[] result = new double[n];
for (int i = 0; i < n; i++) {
result[i] = a[i] - b[i];
}
return result;
}
private static double[][] readMatrix(Scanner scanner) {
[Link]("Número de filas: ");
int rows = [Link]();
[Link]("Número de columnas: ");
int cols = [Link]();
double[][] matrix = new double[rows][cols];
[Link]("Ingrese los elementos de la matriz:");
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
matrix[i][j] = [Link]();
}
}
return matrix;
}
private static double[] readVector(Scanner scanner, int size) {
double[] vector = new double[size];
[Link]("Ingrese los elementos del vector:");
for (int i = 0; i < size; i++) {
vector[i] = [Link]();
}
return vector;
}
private static void printVector(double[] vector) {
for (double val : vector) {
[Link](val + " ");
}
[Link]();
}
