Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download
2037 views
ubuntu2004
Tweet
Share
Share
Kernel: Octave

Método de Gauss-Jordan en Octave

En esta publicación, te explicaré como desarrollar el método de Gauss-Jordan utilizando el lenguaje de programación Octave. Sin embargo, puedes realizar todas y cada una de las operaciones con tu propia calculadora y verificar cada uno de los pasos.

Esta libreta esta desarrollada en Cocalc y podrás acceder libremente. Si deseas aprender un poco sobre Octave, te invito a que veas este vídeotutorial.

En este ejercicio, aplicaremos el método de Gauss-Jordan para resolver el sistema 4x−y+z=−12x+3y−z=5−x+2y+3z=0 4x-y+z = -1 \\ 2x+3y-z = 5 \\ -x +2y +3z = 0 

# Reescribimos nuestro sistema en forma de matriz aumentada.
A = [4 -1 1 -1; 2 3 -1 5; -1 2 3 0]
A = 4 -1 1 -1 2 3 -1 5 -1 2 3 0

Las dos operaciones que usaremos son

  1. Ri<−Ri/AiiR_i <- R_i/ A_{ii}, donde RiR_i denota el i-ésimo renglón de AA y AijA_{ij}, el elemento de AA en el renglón ii y columna jj.

  2. Ri<−Ri−Ai,jRjR_i <- R_i - A_{i,j}R_j

A la primera operación la denotaremos como normalización, ya que transformará el elemento Ai,iA_{i,i} en 1, mientras que a la segunda le llamaremos anulación, ya que transformará el elemento Ai,jA_{i,j} en cero, provisto de que el renglón jj esté normalizado.

En Octave, podemos extraer el ii-ésimo renglón de AA con el código A(i, :), y acceder al elemento Ai,jA_{i,j} con A(i,j). ¡Comencemos!

# Normalizamos el primer renglón de A
A(1, : ) = A(1, : )/4
A = 1.0000 -0.2500 0.2500 -0.2500 2.0000 3.0000 -1.0000 5.0000 -1.0000 2.0000 3.0000 0 
# Anulamos el elemento A21
A(2, : ) = A(2, :) - A(2,1)*A(1, : )
A = 1.0000 -0.2500 0.2500 -0.2500 0 3.5000 -1.5000 5.5000 -1.0000 2.0000 3.0000 0 
# Anulamos el elemento A31
A(3, : ) = A(3, :) - A(3,1)*A(1, : )
A = 1.0000 -0.2500 0.2500 -0.2500 0 3.5000 -1.5000 5.5000 0 1.7500 3.2500 -0.2500

Como ya seguramente observaste, tendremos que repetir esta dos operaciones varias veces. Por lo que nos conviene escribirlas en forma de funciones, a fin evitar repetir el código de manera innecesaria. 

# Función para normalizar un renglón dado en una matriz
function matriz = normalizar(matriz, renglon)
    matriz(renglon, : ) = matriz(renglon, : )/matriz(renglon, renglon)
endfunction

# Probamos nuestra función con el segundo renglón
A = normalizar(A, 2)
matriz = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 1.7500 3.2500 -0.2500 A = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 1.7500 3.2500 -0.2500 
# Una vez normalizado el renglón i, podemos anular el elemento Aij con esta función
function matriz = anular(matriz,renglon, columna)
    matriz(renglon, : ) = matriz(renglon, :) - matriz(renglon,columna)*matriz(columna, : )
end

# Probamos a anular el elemento A32
A = anular(A, 3, 2)
matriz = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 0 4.0000 -3.0000 A = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 0 4.0000 -3.0000 
# Finalmente, normalizamos el renglón 3
A = normalizar(A, 3)
matriz = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 0 1.0000 -0.7500 A = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 -0.4286 1.5714 0 0 1.0000 -0.7500

Hasta este punto, hemos encontrado una matriz triangular superior, equivalente a nuestra matriz original. Lo que resta por hacer diagonalizar la matriz, lo cual haremos en el siguiente bloque. 

A = anular(A, 2, 3)
A = anular(A, 1, 3)
A = anular(A, 1, 2)
matriz = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 0 1.2500 0 0 1.0000 -0.7500 A = 1.0000 -0.2500 0.2500 -0.2500 0 1.0000 0 1.2500 0 0 1.0000 -0.7500 matriz = 1.0000 -0.2500 0 -0.0625 0 1.0000 0 1.2500 0 0 1.0000 -0.7500 A = 1.0000 -0.2500 0 -0.0625 0 1.0000 0 1.2500 0 0 1.0000 -0.7500 matriz = 1.0000 0 0 0.2500 0 1.0000 0 1.2500 0 0 1.0000 -0.7500 A = 1.0000 0 0 0.2500 0 1.0000 0 1.2500 0 0 1.0000 -0.7500

¡Listo! Lo hemos conseguido. Por supuesto, siendo Octave un lenguaje de programación dedicado a trabajar con matrices, este procedimiento este implementado de bajo el nombre de la función rref(), que es capaz de manejar casos particulares donde la matriz no es diagonalizable o se requieren permutaciones de renglones. 

A = [4 -1 1 -1; 2 3 -1 5; -1 2 3 0]
rref(A)
A = 4 -1 1 -1 2 3 -1 5 -1 2 3 0 ans = 1.0000 0 0 0.2500 0 1.0000 0 1.2500 0 0 1.0000 -0.7500

Si esta entrada te ha gustado, no olvides suscribirte y regalarnos un comentario. ¡Hasta la próxima!