⚙️ Sistemas de Ecuaciones Lineales con Python #
¡Bienvenido a la segunda cápsula de nuestro curso de Métodos Numéricos! En la ingeniería, es muy común encontrarse con problemas que se modelan a través de sistemas de ecuaciones lineales. Desde el análisis de fuerzas en una armadura (truss) hasta la resolución de circuitos eléctricos o la simulación de flujo de fluidos, la habilidad para resolver estos sistemas de manera eficiente es fundamental.
En esta cápsula, nos centraremos en los métodos directos y métodos iterativos de resolución. Los primeros buscan la solución exacta en un número finito de pasos, mientras que los segundos refinan una solución inicial hasta que se alcanza un criterio de convergencia.
1. Métodos Directos #
Estos métodos se basan en la manipulación sistemática de las ecuaciones para obtener una solución exacta.
Eliminación Gaussiana #
La Eliminación Gaussiana es un algoritmo fundamental para resolver sistemas de la forma \(Ax = b\), donde \(A\) es una matriz de coeficientes, \(x\) es el vector de incógnitas y \(b\) es el vector de términos constantes. El método consta de dos fases principales:
Fase 1: Eliminación Hacia Adelante #
El objetivo es transformar la matriz de coeficientes \(A\) en una matriz triangular superior. Esto se logra a través de operaciones de fila elementales:
- Intercambiar dos filas.
- Multiplicar una fila por una constante distinta de cero.
- Sumar un múltiplo de una fila a otra.
A través de estas operaciones, se eliminan los elementos debajo de la diagonal principal, creando un sistema equivalente más fácil de resolver.
Pseudocódigo para la Eliminación Gaussiana #
funcion eliminacion_gaussiana(A, b):
n = numero de filas en A
// Combinar A y b en una matriz aumentada
matriz_aumentada = concatenar(A, b)
// Fase de Eliminación Hacia Adelante
para k desde 0 hasta n-1:
para i desde k+1 hasta n-1:
factor = matriz_aumentada[i][k] / matriz_aumentada[k][k]
para j desde k hasta n:
matriz_aumentada[i][j] = matriz_aumentada[i][j] - factor * matriz_aumentada[k][j]
// Fase de Sustitución Hacia Atrás
x = arreglo de tamaño n
para i desde n-1 hasta 0:
suma = 0
para j desde i+1 hasta n-1:
suma = suma + matriz_aumentada[i][j] * x[j]
x[i] = (matriz_aumentada[i][n] - suma) / matriz_aumentada[i][i]
retornar x
Ejemplo de Eliminación Gaussiana #
Consideremos el siguiente sistema de ecuaciones lineales:
$$\begin{align*} 2x + y - z &= 8 \\ -3x - y + 2z &= -11 \\ -2x + y + 2z &= -3 \end{align*}$$Primero, representamos el sistema en una matriz aumentada \([A|b]\):
$$ \begin{pmatrix} 2 & 1 & -1 & | & 8 \\ -3 & -1 & 2 & | & -11 \\ -2 & 1 & 2 & | & -3 \end{pmatrix} $$Paso 1: Convertir el primer elemento de la segunda fila en cero. Para ello, sumamos la segunda fila más \(1.5\) veces la primera fila (\(F_2 \leftarrow F_2 + 1.5 F_1\)).
$$\begin{pmatrix} 2 & 1 & -1 & | & 8 \\ 0 & 0.5 & 0.5 & | & 1 \\ -2 & 1 & 2 & | & -3 \end{pmatrix} $$Paso 2: Convertir el primer elemento de la tercera fila en cero. Para ello, sumamos la tercera fila más \(1\) vez la primera fila (\(F_3 \leftarrow F_3 + 1 F_1\)).
$$ \begin{pmatrix} 2 & 1 & -1 & | & 8 \\ 0 & 0.5 & 0.5 & | & 1 \\ 0 & 2 & 1 & | & 5 \end{pmatrix} $$Paso 3: Convertir el segundo elemento de la tercera fila en cero. Para ello, sumamos la tercera fila menos \(4\) veces la segunda fila (\(F_3 \leftarrow F_3 - 4 F_2\)).
$$\begin{pmatrix} 2 & 1 & -1 & | & 8 \\ 0 & 0.5 & 0.5 & | & 1 \\ 0 & 0 & -1 & | & 1 \end{pmatrix} $$Ahora tenemos una matriz triangular superior.
Fase 2: Sustitución Hacia Atrás #
El sistema se ha transformado en:
$$\begin{align*} 2x + y - z &= 8 \\ 0.5y + 0.5z &= 1 \\ -z &= 1 \end{align*}$$De la última ecuación, obtenemos \(z = -1\).
Sustituyendo en la segunda ecuación: \(0.5y + 0.5(-1) = 1 \implies 0.5y = 1.5 \implies y = 3\).
Sustituyendo en la primera ecuación: \(2x + 3 - (-1) = 8 \implies 2x = 4 \implies x = 2\).
La solución es \(x=2, y=3, z=-1\).
Método de Gauss-Jordan #
El método de Gauss-Jordan es una extensión de la Eliminación Gaussiana. En lugar de detenerse en la matriz triangular superior, continúa el proceso de eliminación para obtener una matriz de identidad en el lado izquierdo. Al final del proceso, el vector de términos constantes \(b\) se transforma directamente en el vector de solución \(x\). Este método es particularmente útil para calcular la inversa de una matriz.
Pseudocódigo para Gauss-Jordan #
funcion gauss_jordan(A, b):
n = numero de filas en A
// Combinar A y b en una matriz aumentada
matriz_aumentada = concatenar(A, b)
para k desde 0 hasta n-1:
// Normalizar la fila k para que el pivote sea 1
pivote = matriz_aumentada[k][k]
para j desde k hasta n:
matriz_aumentada[k][j] = matriz_aumentada[k][j] / pivote
// Eliminar todos los demás elementos de la columna k
para i desde 0 hasta n-1:
si i != k:
factor = matriz_aumentada[i][k]
para j desde k hasta n:
matriz_aumentada[i][j] = matriz_aumentada[i][j] - factor * matriz_aumentada[k][j]
// La solución está en la última columna
retornar matriz_aumentada[:, n]
Ejemplo de Gauss-Jordan #
Tomando la matriz triangular superior del ejemplo anterior, continuamos el proceso.
$$ \begin{pmatrix} 2 & 1 & -1 & | & 8 \\ 0 & 0.5 & 0.5 & | & 1 \\ 0 & 0 & -1 & | & 1 \end{pmatrix} $$Paso 1: Convertimos la matriz de coeficientes en la identidad. Para ello, primero normalizamos las filas para que los elementos de la diagonal sean 1.
- \(F_1 \leftarrow F_1 / 2\)
- \(F_2 \leftarrow F_2 / 0.5\)
- \(F_3 \leftarrow F_3 / (-1)\)
Paso 2: Eliminamos los elementos por encima de la diagonal.
- \(F_2 \leftarrow F_2 - 1 F_3\)
- \(F_1 \leftarrow F_1 - (-0.5) F_3\)
Paso 3: Eliminamos el último elemento por encima de la diagonal.
- \(F_1 \leftarrow F_1 - 0.5 F_2\)
El vector de solución \(x\) es ahora la columna de los términos constantes: \(x=2, y=3, z=-1\).
Descomposición LDU (o LU) #
La Descomposición LDU (Lower-Diagonal-Upper) o LU (Lower-Upper) es una factorización de una matriz cuadrada \(A\) en tres (o dos) matrices triangulares.
$$A = LDU$$- L: Una matriz triangular inferior con unos en la diagonal.
- D: Una matriz diagonal.
- U: Una matriz triangular superior con unos en la diagonal.
Esta descomposición es una herramienta poderosa porque, una vez que se descompone la matriz \(A\), resolver múltiples sistemas de la forma \(Ax = b\) se vuelve computacionalmente mucho más rápido que si se hiciera cada vez por eliminación gaussiana. Esto es ideal para problemas que requieren resolver el mismo sistema con diferentes cargas o términos constantes.
Pseudocódigo para la Descomposición LU #
funcion descomposicion_LU(A):
n = tamaño de la matriz
L = matriz n x n inicializada a ceros (con 1s en la diagonal)
U = matriz n x n inicializada a ceros
para k desde 0 hasta n-1:
U[k][k] = A[k][k]
para i desde k+1 hasta n-1:
L[i][k] = A[i][k] / U[k][k]
U[k][i] = A[k][i]
para i desde k+1 hasta n-1:
para j desde k+1 hasta n-1:
A[i][j] = A[i][j] - L[i][k] * U[k][j]
retornar L, U
funcion resolver_LU(L, U, b):
n = tamaño de la matriz
y = arreglo de tamaño n
x = arreglo de tamaño n
// Sustitución hacia adelante para Ly = b
para i desde 0 hasta n-1:
suma = 0
para j desde 0 hasta i-1:
suma = suma + L[i][j] * y[j]
y[i] = b[i] - suma
// Sustitución hacia atrás para Ux = y
para i desde n-1 hasta 0:
suma = 0
para j desde i+1 hasta n-1:
suma = suma + U[i][j] * x[j]
x[i] = (y[i] - suma) / U[i][i]
retornar x
Ejemplo de Descomposición LDU #
Consideremos la matriz \(A\) del sistema \(Ax = b\):
$$A = \begin{pmatrix} 2 & 1 \\ 4 & 3 \end{pmatrix}$$El objetivo es encontrar una matriz triangular inferior \(L\) y una matriz triangular superior \(U\) tal que \(A = LU\).
$$A = \begin{pmatrix} 2 & 1 \\ 4 & 3 \end{pmatrix} = L \cdot U = \begin{pmatrix} 1 & 0 \\ l_{21} & 1 \end{pmatrix} \begin{pmatrix} u_{11} & u_{12} \\ 0 & u_{22} \end{pmatrix}$$Multiplicando las matrices L y U:
$$ \begin{pmatrix} 1 \cdot u_{11} & 1 \cdot u_{12} \\ l_{21} \cdot u_{11} & l_{21} \cdot u_{12} + 1 \cdot u_{22} \end{pmatrix} = \begin{pmatrix} 2 & 1 \\ 4 & 3 \end{pmatrix} $$Igualando los elementos correspondientes:
- \(u_{11} = 2\)
- \(u_{12} = 1\)
- \(l_{21} \cdot u_{11} = 4 \implies l_{21} \cdot 2 = 4 \implies l_{21} = 2\)
- \(l_{21} \cdot u_{12} + u_{22} = 3 \implies 2 \cdot 1 + u_{22} = 3 \implies u_{22} = 1\)
Por lo tanto, las matrices L y U son:
$$L = \begin{pmatrix} 1 & 0 \\ 2 & 1 \end{pmatrix} \quad \text{y} \quad U = \begin{pmatrix} 2 & 1 \\ 0 & 1 \end{pmatrix}$$Paso 2: Resolución del sistema Para resolver \(Ax=b\), lo reescribimos como \(LUx = b\). Este problema se descompone en dos pasos más simples:
- Resolver \(Ly = b\) para encontrar el vector intermedio \(y\).
- Resolver \(Ux = y\) para encontrar el vector de solución \(x\).
Consideremos el vector \(b = \begin{pmatrix} 7 \\ 17 \end{pmatrix}\).
Resolviendo \(Ly = b\) (sustitución hacia adelante):
$$\begin{pmatrix} 1 & 0 \\ 2 & 1 \end{pmatrix} \begin{pmatrix} y_1 \\ y_2 \end{pmatrix} = \begin{pmatrix} 7 \\ 17 \end{pmatrix}$$- \(1y_1 + 0y_2 = 7 \implies y_1 = 7\)
- \(2y_1 + 1y_2 = 17 \implies 2(7) + y_2 = 17 \implies y_2 = 3\)
Ahora tenemos el vector \(y = \begin{pmatrix} 7 \\ 3 \end{pmatrix}\).
Resolviendo \(Ux = y\) (sustitución hacia atrás):
$$\begin{pmatrix} 2 & 1 \\ 0 & 1 \end{pmatrix} \begin{pmatrix} x_1 \\ x_2 \end{pmatrix} = \begin{pmatrix} 7 \\ 3 \end{pmatrix}$$- \(0x_1 + 1x_2 = 3 \implies x_2 = 3\)
- \(2x_1 + 1x_2 = 7 \implies 2x_1 + 3 = 7 \implies x_1 = 2\)
La solución final es \(x = \begin{pmatrix} 2 \\ 3 \end{pmatrix}\).
2. Métodos Iterativos #
A diferencia de los métodos directos que buscan una solución exacta, los métodos iterativos comienzan con una suposición inicial de la solución y la refinan gradualmente a través de un proceso repetitivo. Son particularmente útiles para sistemas de ecuaciones muy grandes y dispersos, donde los métodos directos son ineficientes o inviables.
El principio central es reescribir el sistema \(Ax = b\) en la forma \(x = Tx + c\), de tal manera que, al iterar la fórmula, la solución converja.
Método de Jacobi #
El método de Jacobi utiliza la siguiente fórmula de iteración, despejando cada incógnita \(x_i\) de la \(i\)-ésima ecuación:
$$x_i^{(k+1)} = \frac{1}{a_{ii}} \left( b_i - \sum_{j \neq i} a_{ij} x_j^{(k)} \right)$$En este método, para calcular los nuevos valores en la iteración \((k+1)\), se utilizan los valores del vector de la iteración anterior \((k)\). Todos los valores de la nueva iteración se calculan “simultáneamente” al final del paso.
Pseudocódigo para el Método de Jacobi #
funcion jacobi(A, b, suposicion_inicial, tolerancia, max_iteraciones):
n = tamaño del sistema
x = suposicion_inicial.copia()
para k desde 0 hasta max_iteraciones:
x_nuevo = arreglo de tamaño n
para i desde 0 hasta n-1:
suma = 0
para j desde 0 hasta n-1:
si i != j:
suma = suma + A[i][j] * x[j]
x_nuevo[i] = (b[i] - suma) / A[i][i]
// Criterio de parada
si norma(x_nuevo - x) < tolerancia:
retornar x_nuevo
x = x_nuevo.copia()
// Si no converge
retornar "No converge después de max_iteraciones"
Ejemplo del Método de Jacobi #
Consideremos el siguiente sistema de ecuaciones, el cual es estrictamente diagonal dominante, una condición que garantiza la convergencia del método.
$$\begin{align*} 5x - y + z &= 10 \\ 2x + 8y - z &= 11 \\ -x + y + 4z &= 12 \end{align*}$$Despejamos cada incógnita:
- \(x^{(k+1)} = \frac{1}{5} (10 + y^{(k)} - z^{(k)})\)
- \(y^{(k+1)} = \frac{1}{8} (11 - 2x^{(k)} + z^{(k)})\)
- \(z^{(k+1)} = \frac{1}{4} (12 + x^{(k)} - y^{(k)})\)
Tomamos una suposición inicial \(x^{(0)} = y^{(0)} = z^{(0)} = 0\).
Iteración 1:
- \(x^{(1)} = \frac{1}{5}(10 + 0 - 0) = 2.0\)
- \(y^{(1)} = \frac{1}{8}(11 - 2(0) + 0) = 1.375\)
- \(z^{(1)} = \frac{1}{4}(12 + 0 - 0) = 3.0\)
Iteración 2:
- \(x^{(2)} = \frac{1}{5}(10 + 1.375 - 3.0) = 1.675\)
- \(y^{(2)} = \frac{1}{8}(11 - 2(2.0) + 3.0) = 1.25\)
- \(z^{(2)} = \frac{1}{4}(12 + 2.0 - 1.375) = 3.15625\)
El proceso continúa hasta que la diferencia entre iteraciones sea menor que una tolerancia predefinida.
Método de Gauss-Seidel #
El método de Gauss-Seidel es una mejora del método de Jacobi. También se despeja cada incógnita \(x_i\), pero con una diferencia crucial: al calcular un nuevo valor \(x_i^{(k+1)}\), se usan los valores más recientes y actualizados de las incógnitas ya calculadas en la misma iteración.
$$x_i^{(k+1)} = \frac{1}{a_{ii}} \left( b_i - \sum_{j < i} a_{ij} x_j^{(k+1)} - \sum_{j > i} a_{ij} x_j^{(k)} \right)$$Esta “actualización en tiempo real” suele hacer que el método de Gauss-Seidel converja más rápido que el de Jacobi.
Pseudocódigo para el Método de Gauss-Seidel #
funcion gauss_seidel(A, b, suposicion_inicial, tolerancia, max_iteraciones):
n = tamaño del sistema
x = suposicion_inicial.copia()
para k desde 0 hasta max_iteraciones:
x_anterior = x.copia()
para i desde 0 hasta n-1:
suma = 0
para j desde 0 hasta n-1:
si i != j:
suma = suma + A[i][j] * x[j]
x[i] = (b[i] - suma) / A[i][i]
// Criterio de parada
si norma(x - x_anterior) < tolerancia:
retornar x
// Si no converge
retornar "No converge después de max_iteraciones"
Ejemplo del Método de Gauss-Seidel #
Usando el mismo sistema anterior y la misma suposición inicial:
$$\begin{align*} 5x - y + z &= 10 \\ 2x + 8y - z &= 11 \\ -x + y + 4z &= 12 \end{align*}$$Iteración 1:
- \(x^{(1)} = \frac{1}{5}(10 + 0 - 0) = 2.0\)
- \(y^{(1)} = \frac{1}{8}(11 - 2\textbf{(2.0)} + 0) = 0.875\) (Nótese que se usa el valor de \(x\) ya calculado).
- \(z^{(1)} = \frac{1}{4}(12 + \textbf{2.0} - \textbf{0.875}) = 3.28125\) (Se usan los valores de \(x\) e \(y\) actualizados).
Iteración 2:
- \(x^{(2)} = \frac{1}{5}(10 + 0.875 - 3.28125) = 1.51875\)
- \(y^{(2)} = \frac{1}{8}(11 - 2(1.51875) + 3.28125) = 1.28046875\)
- \(z^{(2)} = \frac{1}{4}(12 + 1.51875 - 1.28046875) = 3.0595703125\)
3. Resolución con Librerías de Python #
Si bien es fundamental entender los algoritmos, en la práctica profesional, los ingenieros utilizan librerías optimizadas para resolver sistemas lineales de manera rápida y eficiente. Estas librerías están escritas en lenguajes de bajo nivel como C o Fortran, lo que las hace mucho más rápidas que una implementación en Python puro.
NumPy: El Caballo de Batalla #
La librería NumPy es la base de la computación científica en Python. Ofrece la función np.linalg.solve() que utiliza algoritmos robustos (a menudo una descomposición LU o similar) para resolver sistemas de ecuaciones lineales de forma directa y eficiente.
import numpy as np
# Definir la matriz de coeficientes A
A = np.array([[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2]])
# Definir el vector de términos constantes b
b = np.array([8, -11, -3])
# Resolver el sistema Ax = b
x = np.linalg.solve(A, b)
print("La solución es:", x)
# Resultado: La solución es: [ 2. 3. -1.]
SciPy: El Laboratorio de Métodos Numéricos #
La librería SciPy se construye sobre NumPy y contiene un vasto conjunto de algoritmos numéricos. Su módulo scipy.linalg incluye funciones para resolver sistemas lineales, calcular inversas y realizar descomposiciones como la LU.
import numpy as np
import scipy.linalg as la
A = np.array([[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2]])
b = np.array([8, -11, -3])
# Resolver el sistema
x = la.solve(A, b)
print("La solución es:", x)
# Resultado: La solución es: [ 2. 3. -1.]
SymPy: Matemáticas Simbólicas #
Para resolver sistemas de ecuaciones de forma simbólica (sin valores numéricos, manteniendo las variables), la librería SymPy es la herramienta ideal. Permite definir variables y matrices simbólicas para obtener soluciones exactas en forma de fracciones o expresiones algebraicas.
from sympy import Matrix, linsolve, symbols
x, y, z = symbols('x, y, z')
# Definir la matriz de coeficientes y el vector de términos constantes
A = Matrix([[2, 1, -1],
[-3, -1, 2],
[-2, 1, 2]])
b = Matrix([8, -11, -3])
# Resolver el sistema Ax = b
solucion = linsolve((A, b), (x, y, z))
print("La solución simbólica es:", solucion)
# Resultado: La solución simbólica es: {(2, 3, -1)}
Casos Aplicados en Ingeniería Mecánica #
Análisis Estructural: Método de las Rigideces #
En el análisis de estructuras, como armaduras o marcos, se modela el sistema a través de un sistema de ecuaciones lineales que relaciona las fuerzas aplicadas con los desplazamientos de los nudos. La ecuación matricial es:
$$K \cdot x = F$$Donde:
- \(K\) es la matriz de rigidez global del sistema.
- \(x\) es el vector de desplazamientos (incógnitas).
- \(F\) es el vector de fuerzas aplicadas (términos constantes).
Los métodos de Eliminación Gaussiana o la descomposición LU son la base de los solucionadores de software de Elementos Finitos (FEM) para encontrar los desplazamientos en cada nudo y, a partir de ellos, los esfuerzos y deformaciones en los elementos.
Análisis de Transferencia de Calor por Conducción #
En problemas de ingeniería térmica, la distribución de la temperatura en una placa o un componente se puede discretizar en una serie de nodos, y la temperatura en cada nodo se rige por un sistema de ecuaciones lineales.
Por ejemplo, para una placa con fuentes de calor, la ecuación de balance de energía en cada nodo \(i\) es:
$$T_i = \frac{1}{4} (T_{i-1} + T_{i+1} + T_{i-4} + T_{i+4}) + Q_i$$Este tipo de sistema genera una matriz de coeficientes grande y dispersa (muchos elementos son cero), lo que lo hace ideal para ser resuelto con métodos iterativos como Gauss-Seidel, que son más eficientes en este tipo de matrices que los métodos directos.
Ejercicios Prácticos: ¡Manos a la Obra! #
- Eliminación Gaussiana a mano: Resuelve el siguiente sistema de ecuaciones usando un bolígrafo y papel, mostrando los pasos de eliminación:
- \(2x + y = 5\)
- \(4x - 2y = 2\)
- Eliminación Gaussiana con Python: Implementa una función en Python para resolver un sistema \(Ax=b\) utilizando la eliminación gaussiana.
- Gauss-Jordan con Python: Modifica tu función del ejercicio anterior para implementar el método de Gauss-Jordan.
- Descomposición LDU (LU) con NumPy: Usa
scipy.linalg.lu()para encontrar las matricesL,Uy la matriz de permutaciónPdel siguiente sistema:
- \(A = \begin{pmatrix} 2 & 1 \\ 4 & 3 \end{pmatrix}\)
- \(b = \begin{pmatrix} 7 \\ 17 \end{pmatrix}\)
- Descomposición LDU con Python: Utiliza las matrices
L,UyPdel ejercicio anterior para resolver el sistema \(Ax = b\). - Problema de Ingeniería: Un sistema de poleas se modela por el siguiente sistema de ecuaciones. Usa
numpy.linalg.solve()para encontrar las tensiones \(T_1\), \(T_2\) y \(T_3\).
- \(T_1 - T_2 = 10\)
- \(2T_2 - T_3 = 20\)
- \(T_1 + T_3 = 30\)
- Condicionamiento de Matrices: Crea una matriz mal condicionada (una con determinante muy cercano a cero) e intenta resolver un sistema con ella. ¿Qué pasa con la solución?
- Ejemplo de circuito: Un circuito con 3 mallas da el siguiente sistema de ecuaciones. Resuelve para las corrientes \(I_1, I_2, I_3\) usando los métodos de esta cápsula.
- \(2I_1 - I_2 = 5\)
- \(-I_1 + 3I_2 - I_3 = 10\)
- \(-I_2 + 4I_3 = 15\)
- Análisis de Estructuras (simple): Para el análisis de una armadura simple, las ecuaciones de equilibrio de las fuerzas en un nudo son:
- \(0.5F_1 + 0.866F_2 = 100\)
- \(0.866F_1 - 0.5F_2 = 0\) Usa el método de la Eliminación Gaussiana para encontrar las fuerzas \(F_1\) y \(F_2\).
- Ventajas y Desventajas: ¿Cuál es la principal ventaja de la descomposición LDU sobre la eliminación Gaussiana para resolver múltiples sistemas con la misma matriz \(A\)?
- Implementación de Jacobi: Escribe una función en Python para resolver un sistema \(Ax=b\) utilizando el método de Jacobi.
- Implementación de Gauss-Seidel: Escribe una función en Python para resolver un sistema \(Ax=b\) utilizando el método de Gauss-Seidel.
- Convergencia: Para el sistema del ejercicio 8, usa tu implementación de Jacobi y Gauss-Seidel. Compara el número de iteraciones que necesita cada método para alcanzar una tolerancia de \(10^{-6}\).
- Condición de Diagonal Dominante: ¿Qué es una matriz “estrictamente diagonal dominante”? ¿Por qué esta es una condición suficiente para la convergencia de los métodos de Jacobi y Gauss-Seidel?
- Comparación de métodos: Compara la eficiencia (o el tiempo de cálculo) para resolver un sistema \(Ax=b\) grande utilizando
numpy.linalg.solve()vs. tu propia implementación de Gauss-Jordan. - Matriz Simétrica: Investiga sobre la descomposición de Cholesky. ¿En qué tipo de matrices se puede usar y cuál es su principal ventaja?
- Errores: ¿Qué significa que una matriz sea “singular”? ¿Qué sucede con los métodos directos si la matriz \(A\) es singular?
- Descomposición QR: Investiga qué es la descomposición QR y para qué tipo de problemas se utiliza en la ingeniería.
- Código de Eliminación: Escribe el código completo de la fase de sustitución hacia atrás para tu función de Eliminación Gaussiana.
- Código de Gauss-Jordan: Escribe el código completo para la fase de eliminación hacia atrás para tu función de Gauss-Jordan.
- Análisis de Circuitos Avanzado: Resuelve el sistema del ejercicio 8, pero esta vez con
scipy.linalg.solve. Compara el resultado. - Ajuste de Cargas: Un ingeniero necesita resolver el problema del ejercicio 9, pero con tres cargas diferentes. Utiliza la descomposición LU de la matriz de coeficientes para resolver las tres cargas de forma eficiente.
- Análisis de una Viga: La ecuación de la deflexión de una viga de Euler-Bernoulli se puede discretizar en un sistema lineal. Resuelve para la deflexión en 4 puntos intermedios:
- \(4y_1 - y_2 = 10\)
- \(-y_1 + 4y_2 - y_3 = 0\)
- \(-y_2 + 4y_3 - y_4 = 0\)
- \(-y_3 + 4y_4 = 0\)
- Reto: Escribe una función que resuelva un sistema \(Ax=b\) utilizando la descomposición LDU sin usar ninguna función de NumPy para la descomposición. Es decir, implementa tú mismo el algoritmo de LDU.