Método de Jacobi

 -Fundamento Teórico-

1. 1. Preparación:

   Se organiza el sistema de ecuaciones de manera que cada ecuación tenga una variable despejada. Se seleccionan valores iniciales para las variables.
2. 2. Iteración:

   Se calcula un nuevo valor para cada variable utilizando las ecuaciones despejadas y los valores anteriores de las otras variables.
3. 3. Verificación:

   Se compara el nuevo valor de cada variable con el valor anterior. Si la diferencia es menor que un valor predefinido (criterio de convergencia), se considera que la solución ha convergido. En caso contrario, se vuelve al paso 2.
4. 4. Solución:

   Cuando se alcanza la convergencia, los valores de las variables son las soluciones del sistema de ecuaciones. 

-Algoritmo del Método-

1. 1. Despejar cada variable:

   • Se toma cada ecuación del sistema y se despeja la variable correspondiente a la diagonal principal. 
   • Por ejemplo, si la ecuación es 2x + y - z = 5, se despejará x = (5 - y + z) / 2.
2. 2. Aproximación inicial:

   • Se asignan valores iniciales a las variables. Estos valores pueden ser cero o cualquier otro valor razonable. 
3. 3. Iteración:

   • Se calcula el valor de cada variable usando las ecuaciones despejadas y los valores de la iteración anterior. Por ejemplo, si en la iteración anterior y = 2 y z = 3, entonces se calcula x = (5 - 2 + 3) / 2 = 3. 
   • Se repite este proceso hasta que los valores de las variables se estabilicen o se cumpla un criterio de convergencia. 
4. 4. Criterio de convergencia:

   • Se define una tolerancia para la diferencia entre los valores de las variables en dos iteraciones consecutivas. 
   • Si la diferencia es menor que la tolerancia, se considera que el método ha convergido y se detiene la iteración. 
5. 5. Solución:

   • Los valores de las variables en la última iteración son la solución aproximada del sistema de ecuaciones. 

Ejemplo:

Supongamos el sistema de ecuaciones:

Código

2x + y - z = 5
x + 3y + 2z = 10
y + 4z = 7

1. Despejar:
   • x = (5 - y + z) / 2
   • y = (10 - x - 2z) / 3
   • z = (7 - y) / 4
2. Aproximación inicial:
   • x = 0, y = 0, z = 0
3. Iteración 1:
   • x = (5 - 0 + 0) / 2 = 2.5
   • y = (10 - 0 - 2 * 0) / 3 = 10/3
   • z = (7 - 0) / 4 = 1.75
4. Iteración 2:
   • x = (5 - 10/3 + 1.75) / 2 = 1.458
   • y = (10 - 1.458 - 2 * 1.75) / 3 = 2.916
   • z = (7 - 10/3) / 4 = 1.083
5. ...

Se repite la iteración hasta que se cumpla el criterio de convergencia, por ejemplo, que la diferencia entre los valores de las variables en dos iteraciones consecutivas sea menor que 0.001. 

-Ejercicio Resuelto Paso a Paso-

resolver el siguiente sistema:

$$\begin{cases} 10x + 2y + z = 9 \\ 2x + 20y - 2z = -44 \\ -2x + 3y + 10z = 22 \end{cases}$$

---

✅ Paso 1: Escribir la forma iterativa de Jacobi

Despejamos cada variable en términos de las otras dos:

$$\begin{aligned} x &= \frac{1}{10}(9 - 2y - z) \\ y &= \frac{1}{20}(-44 - 2x + 2z) \\ z &= \frac{1}{10}(22 + 2x - 3y) \end{aligned}$$

---

✅ Paso 2: Elegir una estimación inicial

Sea:

$$x^{(0)} = 0,\quad y^{(0)} = 0,\quad z^{(0)} = 0$$

---

🔁 Iteración 1

Usamos los valores iniciales en las ecuaciones:

$$\begin{aligned} x^{(1)} &= \frac{1}{10}(9 - 2(0) - 0) = 0.9 \\ y^{(1)} &= \frac{1}{20}(-44 - 2(0) + 2(0)) = -2.2 \\ z^{(1)} &= \frac{1}{10}(22 + 2(0) - 3(0)) = 2.2 \end{aligned}$$

---

🔁 Iteración 2

Ahora usamos $x^{(1)}, y^{(1)}, z^{(1)}$:

$$\begin{aligned} x^{(2)} &= \frac{1}{10}(9 - 2(-2.2) - 2.2) = \frac{1}{10}(9 + 4.4 - 2.2) = 1.12 \\ y^{(2)} &= \frac{1}{20}(-44 - 2(0.9) + 2(2.2)) = \frac{1}{20}(-44 - 1.8 + 4.4) = -2.07 \\ z^{(2)} &= \frac{1}{10}(22 + 2(0.9) - 3(-2.2)) = \frac{1}{10}(22 + 1.8 + 6.6) = 3.04 \end{aligned}$$

---

🔁 Iteración 3

$$\begin{aligned} x^{(3)} &= \frac{1}{10}(9 - 2(-2.07) - 3.04) = \frac{1}{10}(9 + 4.14 - 3.04) = 1.01 \\ y^{(3)} &= \frac{1}{20}(-44 - 2(1.12) + 2(3.04)) = \frac{1}{20}(-44 - 2.24 + 6.08) = -2.011 \\ z^{(3)} &= \frac{1}{10}(22 + 2(1.12) - 3(-2.07)) = \frac{1}{10}(22 + 2.24 + 6.21) = 3.045 \end{aligned}$$

---

🛑 Criterio de paro

Podemos detenernos cuando las diferencias entre iteraciones consecutivas sean pequeñas, por ejemplo:

$$|x^{(3)} - x^{(2)}| < 0.01, \quad |y^{(3)} - y^{(2)}| < 0.01, \quad |z^{(3)} - z^{(2)}| < 0.01$$

En este caso:

• $|1.01 - 1.12| = 0.11$

• $|-2.011 - (-2.07)| = 0.059$

• $|3.045 - 3.04| = 0.005$

Todavía no cumple completamente, así que se puede continuar iterando hasta que se estabilicen todos.

---

✅ Aproximación tras varias iteraciones:

Después de unas 6 iteraciones, obtendremos algo cercano a:

$$x \approx 1.0,\quad y \approx -2.0,\quad z \approx 3.0$$

---

📌 Nota

El método de Jacobi requiere que la matriz sea diagonalmente dominante (es decir, que el valor absoluto del coeficiente principal de cada fila sea mayor que la suma de los otros valores absolutos de la misma fila). En este caso:

• Fila 1: $|10| > |2| + |1| = 3$ ✔️

• $0|>|2|+|3|=5$ ✔️

-Código del Método-

import numpy as np

• Fila 2: $|20| > |2| + |2| = 4$ ✔️

• Fila 3: $|10| > |2| + |3| = 5$

import matplotlib.pyplot as plt

# Coeficientes del sistema

A = np.array([

    [10.0, 2.0, 1.0],

    [2.0, 20.0, -2.0],

    [-2.0, 3.0, 10.0]

])

# Vector de constantes

b = np.array([9.0, -44.0, 22.0])

# Condiciones iniciales

x = np.zeros_like(b)

# Número máximo de iteraciones y tolerancia

max_iter = 25

tolerance = 1e-6

# Guardar las soluciones en cada iteración

history = [x.copy()]

# Método de Jacobi

for iteration in range(max_iter):

    x_new = np.zeros_like(x)

   

    for i in range(len(A)):

        s = sum(A[i][j] * x[j] for j in range(len(A)) if j != i)

        x_new[i] = (b[i] - s) / A[i][i]

   

    history.append(x_new.copy())

   

    # Verificación de convergencia

    if np.allclose(x, x_new, atol=tolerance):

        print(f"Convergió en {iteration + 1} iteraciones.")

        break

    x = x_new

# Convertir historial a matriz para graficar

history = np.array(history)

# Mostrar soluciones aproximadas

print("Aproximación final:")

print(f"x = {x[0]:.6f}, y = {x[1]:.6f}, z = {x[2]:.6f}")

# Graficar la convergencia

plt.figure(figsize=(10, 6))

plt.plot(history[:, 0], label='x')

plt.plot(history[:, 1], label='y')

plt.plot(history[:, 2], label='z')

plt.xlabel('Iteración')

plt.ylabel('Valor de la variable')

plt.title('Convergencia del método de Jacobi')

plt.grid(True)

plt.legend()

plt.show()

-Grafica-

-Video Explicativo-

-Conclusión-

El método de Jacobi es una técnica iterativa para resolver sistemas de ecuaciones lineales. Puede ser útil en sistemas grandes donde los métodos directos son computacionalmente costosos.