Método de eliminación Gaussiana para resolver sistemas de ecuaciones

José Fernando Domı́nguez Chávez

Diciembre 2023

1 Análisis
Luego de llevar a cabo mediciones de tiempo de ejecución en un sistema con dimensiones n×n, donde n se encuentra
dentro del intervalo [1, 200], se ha identificado que el comportamiento del tiempo de ejecución en base al tamaño
del sistema del método utilizado es de tipo potencial, esto se puede ver en la gráfica 1. Este comportamiento está
directamente asociado con la naturaleza del proceso de convertir una matriz cuadrada en una matriz triangular
superior, esto debido a que se debe de iterar sobre los elementos de la matriz para normalizarla y transformarla. La
normalización por si sola ya requiere iterar sobre todos los elementos de la matriz, lo cual es ejecutar, aproximada-
mente, n2 instrucciones, lo que en sistemas grandes aporta mucho al tiempo de ejecución. El pivoteo y transformar
la matriz a su forma triangular superior también aportan bastante, ya que en el pivoteo es necesario recorrer toda
una columna para encontrar el valor máximo y, además, recorrer todo un renglón para intercambiar los renglones,
y por último recorrer todos los renglones debajo del pivote para que las entradas de la columna debajo del él sean
0.
Por ende, el comportamiento potencial en la implementación del método radica en la necesidad de realizar
múltiples operaciones sobre los elementos de la matriz, especialmente al iterar a lo largo de sus filas y columnas
para alcanzar la forma triangular superior deseada. Esta repetición de operaciones en los elementos de la matriz
conforme se ajustan para cumplir con las condiciones deseadas, resulta en un tiempo de ejecución prolongado
conforme aumenta el tamaño de la matriz.

60
Tiempo de ejecución (s)

50

40

30

20

10

0 50 100 150 200

Tamaño del sistema (n)
Figure 1: Gráfica de el tiempo de ejecución en base al tamaño del sistema para el método de reducción Gaussiana.

1
2 Memoria de cálculo
La memoria de cálculo para un sistema de ecuaciones 10 × 10:
Matriz original:
 
−4 2 4 1 6 −1 −2 −2 −8 −8 −8
 −8 −3 8 6 10 5 −10 10 −3 10 3
 
 10
 −5 5 3 9 2 −6 8 −6 −10 0 

 5
 −10 9 −6 −4 −10 −2 −5 8 7 −7

 9 −6 −3 7 6 5 −10 −10 −1 7 9
  (1)
 5
 −3 −4 7 7 −4 1 −2 −10 −7 7
−10 −9 1 −5 −7 −3 6 −7 10 6 5
 
 −9 1 8 −1 8 −9 1 2 −2 −7 7
 
 0 2 −2 −4 −6 −9 −10 1 −2 1 2
−9 1 −10 −5 −2 −2 0 4 −7 3 −8

Reducción a una matriz triangular superior:

 
1.0000 −0.5000 −1.0000 −0.2500 −1.5000 0.2500 0.5000 0.5000 2.0000 2.0000 2.0000
 0
 1.0000 0 −0.5714 0.2857 −1.0000 0.8571 −2.0000 −1.8571 −3.7143 −2.7143
 0
 0 1.0000 0.3667 1.6000 −0.0333 −0.7333 0.2000 −1.7333 −2.0000 −1.3333
 0
 0 0 1.0000 1.1827 1.2904 −0.8607 1.7856 −0.5885 0.2016 1.3191 

 0
 0 0 0 1.0000 −2.1771 −1.1596 −9.9043 −2.5766 −1.9371 −4.4068
 0
 0 0 0 0 1.0000 −1.6310 −3.1285 0.6385 1.5746 −0.7230
 0
 0 0 0 0 0 1.0000 3.0377 −0.1118 −1.0124 0.9674 

 0 0 0 0 0 0 0 1.0000 1.0211 0.8242 2.0925 
 
 0 0 0 0 0 0 0 0 1.0000 0.9602 1.5479 
0 0 0 0 0 0 0 0 0 1.0000 −0.8952
(2)
Soluciones después de la sustitución hacia atrás:

x1 = −0.584573
x2 = −0.14098
x3 = −1.4577
x4 = 2.06151
x5 = 0.660853
x6 = −0.991172
x7 = −0.799541
x8 = 0.371929
x9 = 2.4075
x10 = −0.895181

2
 3 Código Octave para implementar el método de reducción Gaussiana.
1 minValores = -10; % Minimo valor para la generacion aleatoria
2 maxValores = 10; % Maximo valor para la generacion aleatoria
3

4 n = input ( ’ Ingrese ␣ el ␣ numero ␣ de ␣ variables : ␣ ’) ; % Se lee el numero de variables

5

6 matriz = zeros (n , n ) ; % Matriz de coeficientes de nxn vacia

7 matrizTI = zeros (n , 1) ; % Matriz de terminos independientes de nx1 vacia
8

9 % Se define una funcion que llenara la matriz dada con entradas aleatorias
10 function [ matrizFinal , matrizTIFinal ] = ll e n a rC o n Al e a to r i os ( matriz , matrizTI ,
minValores , maxValores )
11 ancho = size ( matriz ) (1) ;
12 alto = size ( matriz ) (2) ;
13

14 for renglon =1: ancho % Recorre renglon por renglon

15 for columna =1: alto % Recorre columna por columna
16 matriz ( renglon , columna ) = randi ([ minValores , maxValores ]) ;
17 endfor
18 matrizTI ( renglon ,1) = randi ([ minValores , maxValores ]) ;
19 endfor
20 matrizFinal = matriz ;
21 matrizTIFinal = matrizTI ;
22 endfunction
23

24 % Se define una funcion para normalizar la matriz

25 function [ matrizFinal , matrizTIFinal ] = normalizarMatriz ( matriz , matrizTI )
26 ancho = size ( matriz ) (1) ;
27 alto = size ( matriz ) (2) ;
28

29 % Normaliza entradas del renglon

30 for renglon =1: ancho % Recorre renglon por renglon
31 entradaMaxima = 0;
32 for columna =1: alto % Recorre columna por columna para encontrar el maximo
33 if ( abs ( matriz ( renglon , columna ) ) > entradaMaxima ) % verifica si es mayor
34 entradaMaxima = matriz ( renglon , columna ) ; % reemplaza si es mayor
35 endif
36 endfor
37 for columna =1: alto % Se divide todo el renglon por el maximo encontrado
38 if ( abs ( entradaMaxima ) > 0) % Solo se divide si el maximo no es 0
39 matriz ( renglon , columna ) = matriz ( renglon , columna ) / entradaMaxima ;
40 endif
41 endfor
42 if ( abs ( entradaMaxima ) > 0)
43 % Se divide la entrada de la matriz de terminos independientes por el max
44 matrizTI ( renglon , 1) = matrizTI ( renglon ,1) / entradaMaxima ;
45 endif
46 endfor
47

48 matrizFinal = matriz ;
49 matrizTIFinal = matrizTI ;
50 endfunction
51

52 % Se define una funcion para pivotear

3
53 function [ matrizFinal , matrizTIFinal ] = i n t e r c a m b i a r R e n g l o n M a x i m o ( columna ,
matriz , matrizTI )
54 ancho = size ( matriz ) (1) ;
55 alto = size ( matriz ) (2) ;
56

57 % Encuentra el maximo de la columna

58 maximo = columna ;
59 for renglon = columna : ancho
60 % Verifica si es mayor al que ya se tiene
61 if ( abs ( matriz ( renglon , columna ) ) > abs ( matriz ( maximo , columna ) ) )
62 % si lo es , se reemplaza
63 maximo = renglon ;
64 endif
65 endfor
66

67 % se intercambian los renglones

68 for columnaReemplazo =1: alto
69 temp = matriz ( columna , columnaReemplazo ) ;
70 matriz ( columna , columnaReemplazo ) = matriz ( maximo , columnaReemplazo ) ;
71 matriz ( maximo , columnaReemplazo ) = temp ;
72 endfor
73 temp = matrizTI ( renglon , 1) ;
74 matrizTI ( renglon , 1) = matrizTI ( maximo , 1) ;
75 matrizTI ( maximo , 1) = temp ;
76

77 matrizFinal = matriz ;
78 matrizTIFinal = matrizTI ;
79 endfunction
80

81 function [ resultado1 , resultado2 ] = crearPivote ( matriz ,

matrizTerminosIndependientes , columna )
82 % Se divide la columna elegida por el elemento que se quiere transformar
83 % en pivote
84 pivote = matriz ( columna , columna ) ;
85

86 for i =1: size ( matriz ) (2)

87 if ( ( matriz ( columna , i ) !=0) &&( pivote !=0) )
88 matriz ( columna , i ) = matriz ( columna , i ) / pivote ;
89 endif
90 endfor
91

92 % Dividir el elemento de la matriz de terminos independientes por el pivote

93 if ( ( m a t r i z T e r m i n o s I n d e p e n d i e n t e s ( columna ,1) !=0) &&( pivote !=0) )
94 m a t r i z T e r m i n o s I n d e p e n d i e n t e s ( columna ,1) =
m a t r i z T e r m i n o s I n d e p e n d i e n t e s ( columna ,1) / pivote ;
95 endif
96 % Se haran 0 las entradas en la columna del pivote
97 if ( columna != size ( matriz ) (1) )
98 % se tomara el numero de columna como el de renglon , si este numero no es
igual
99 % al tamano de la matriz , entonces se recorreran todos los renglones que
tiene
100 % debajo para hacer que cualquier entrada en la columna del pivote sea 0
101 for i = columna +1: size ( matriz ) (1)
102 % Se elegira como factor la entrada que esta en la columna del pivote
103 % como el pivote es 1 , para que dicha entrada sea 0 solo hace falta

4
104 % restarle el valor de dicha entrada , pero para mantener la equivalencia
105 % se hara lo mismo en todo el renglon .
106 factor = matriz (i , columna ) ;
107 for j =1: size ( matriz ) (2)
108 % Se resta el factor multiplicado por la entrada del renglon del pivote
109 % con quien comparte columna el elemento actual .
110 matriz (i , j ) = matriz (i , j ) - factor * matriz ( columna , j ) ;
111 endfor
112 % Se hace lo mismo , pero para la entrada en la matriz de terminos
independientes
113 m a t r i z T e r m i n o s I n d e p e n d i e n t e s (i ,1) = m a t r i z T e r m i n o s I n d e p e n d i e n t e s (i ,1) -
factor * m a t r i z T e r m i n o s I n d e p e n d i e n t e s ( columna ,1) ;
114 endfor
115 endif
116 % Se devuelven las matrices
117 resultado1 = matriz ;
118 resultado2 = m a t r i z T e r m i n o s I n d e p e n d i e n t e s ;
119 endfunction
120

121 function [ resultado1 , resultado2 ] = reducirMatriz ( matriz ,

matrizTerminosIndependientes )
122 for i =1: size ( matriz ) (2) % Recorre la matriz columna por columna
123 % crea un pivote en la columna actual con pivoteo
124 i n t e r c a m b i a r R e n g l o n M a x i m o (i , matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s ) ;
125 [ r1 , r2 ] = crearPivote ( matriz , matrizTerminosIndependientes , i ) ;
126

127 matriz = r1 ;
128 m a t r i z T e r m i n o s I n d e p e n d i e n t e s = r2 ;
129 endfor
130 % Devuelve las matrices resultantes del proceso
131 resultado1 = matriz ;
132 resultado2 = m a t r i z T e r m i n o s I n d e p e n d i e n t e s ;
133 endfunction
134

135 function resultado = resolverSistema ( matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s )

136 % Se guardan las dimensiones de la matriz
137 renglones = size ( matriz ) (1) ;
138 columnas = size ( matriz ) (2) ;
139

140 % Se crea una matriz donde iran los valores de X

141 valoresX = zeros (1 , columnas ) ;
142

143 % Se normaliza la matriz

144 [ matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s ] = normalizarMatriz ( matriz ,
matrizTerminosIndependientes );
145

146 % Se reduce la matriz para poder calcular los valores de X

147 [ matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s ] =
reducirMatriz ( matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s ) ;
148

149

150 % Se recorre la matriz renglon por renglon , despejando la X sin valor

151 for i =0: renglones -1
152 % Puesto que el termino independiente es el unico que ya esta depejado ,
153 % solo se asigna su valor
154 valorX = m a t r i z T e r m i n o s I n d e p e n d i e n t e s ( renglones -i ,1) ;

5
155 % Se recorre columna por columna
156 for j =0: columnas -1
157 % Cuando el numero de renglon sea igual al de columna ( un pivote ) se
158 % despejara el termino que lo acompana y pasara dividiendo
159 if ( ( renglones - i ) ==( columnas - j ) )
160 % Se despeja X
161 valorX = valorX /( matriz (( renglones - i ) ,( columnas - j ) ) ) ;
162 % Se guarda su valor
163 valoresX (1 , columnas - j ) = valorX ;
164 % Termina el ciclo
165 break ;
166 else
167 % Si eso no pasa , se van despejando los demas terminos pasandolos al
168 % otro lado restando , los valores de X anteriores al que se quiere
calcular
169 % ya deberian estar calculados , asi que se puee usar su valor .
170 valorX = valorX -
matriz (( renglones - i ) ,( columnas - j ) ) * valoresX (1 ,( columnas - j ) ) ;
171 endif
172 endfor
173 endfor
174 % Devuelve la matriz de resultados
175 resultado = valoresX ;
176 endfunction
177

178 function i m p r i m i r M a t r i z A u m e n t a d a ( matriz , m a t r i z T e r m i n o s I n d e p e n d i e n t e s )

179 matrizAumentada = [ matriz m a t r i z T e r m i n o s I n d e p e n d i e n t e s ];
180 disp ( matrizAumentada ) ;
181 end
182

183 % Llenar la matriz con numeros aleatorios

184 [ matriz , matrizTI ] = l l e na r C on A l e at o r io s ( matriz , matrizTI , minValores ,
maxValores ) ;
185 % Mostrar la matriz original del sistema
186 display ( matriz ) ;
187 display ( matrizTI ) ;
188 % Se imprimen los valores de X
189 for i =1: size ( resultados ) (2)
190 printf ( " x % d ␣ = ␣ % d \ n " , i , resultados (1 , i ) ) ;
191 endfor