Universidad Nacional del Nordeste (UNNE)

Maestrı́a en Ciencias de la Ingenierı́a

Cálculo Numérico

Marcelo I. Adotti
Ing. Electromecánico
17 de octubre de 2017

Resumen
Carpeta de trabajos prácticos del curso de Cálculo Numérico, dicta-
do en la cohorte 2016 de la Maestrı́a en Ciencias de la Ingenierı́a. Para
la resolución de los problemas planteados en las distintas guı́as se uti-
lizó software opensource ”Octave GNU”. Para la edición del texto se ha
utilizado LA TE X.

1
1. Eliminación de Gauss
1.1. gauss simple y main gauss
a) A partir de los pseudocódigos del libro de Chapra, se desarrolló en etapas
el código computacional que resuelve un sistema de ecuaciones algebraicas
lineales utilizando la eliminación de Gauss, con pivoteo parcial. En primera
instancia se hizo una prueba con un código simple al que denomino ”gauss
simple b)” con el cual se hace un seguimiento de los procesos de eliminación
hacia adelante y sustitución hacia atrás. Una vez lograda la resolución del
sistema de ecuaciones bien condicionado, se procede a realizar el código de
Gauss con pivoteo parcial solicitado. Este último está escrito modularmente,
es decir que se han utilizado distintas sub-funciones, para luego llamarlas
dentro de un cuerpo principal ”main gauss c)”.
b) gauss simple
## Ejemplo 9 . 5 d e l l i b r o de Chapra , pag . 258
clear all
clc
format l o n g
d i s p l a y ( ” Matriz de c o e f i c i e n t e s dato ” ) ;
A=[3 −0.1 − 0 . 2 ; 0 . 1 7 − 0 . 3 ; 0 . 3 −0.2 1 0 ]
maxcoef=max(max(A ) ) ;
m a t r i x c t r l=A/ maxcoef ;
c o n t r o l=d e t (A ) ;
d i s p l a y ( ” Matriz de t e r m i n o s i n d e p e n t e dato ” ) ;
B= [ 7 . 8 5 ; − 1 9 . 3 ; 7 1 . 4 ]
##paquete de e l i m i n a c i o n h a c i a a d e l a n t e
#para gauss−s i m p l e
##
n=l e n g t h (A ( 1 , : ) ) ;
##e l b u c l e f o r k e s e l e n c a r g a d o de p o s i c i o n a r s e s o b r e e l p i v o t
## de l a m a t r i z A
f o r k=1:n−1
#e l b u c l e f o r i g e n e r a r a l a f i l a de l a m a t r i z t r i a n g u l a r , en f u n c i o n
#a l a e l e m i n a c i o n , a r r a n c a d e s d e l a 2da f i l a d e b i d o a que l a p r i m e r a
#f i l a e s l a d e l p i v o t
f o r i=k+1:n
# f f e s e l f a c t o de p i v o t e o , en f u n c i o n a l e l e m e n t o A( k , k ) , e s t e i r a
# m o d i f i c a n d o s e cuando e l p r o c e s o de e l i m i n a c i o n
f f =A( i , k ) /A( k , k ) ;
# e l b u c l e f o r j , g e n e r a r a l a s columnas de l a m a t r i z t r i a n g u l a r , a l s e r l a
# m a t r i z t r i a g u n l a r e l e l e m e n t o A( 2 , 1 ) ya no e x i s t e en l a segunda f i l a por
# e s o j a r r a n c a d es d e 2
f o r j=k+1:n
A( i , j )=A( i , j )− f f ∗A( k , j ) ; %aca s e r e s t a n l o s a22− f f ∗ a21 , s u c e s i v a m e n t e

2
 %cambian de sub i n d i c e s , s e g e n e r a r a n a22 ’
A( i , k)=A( i , k)−A( i , k ) ; %a c e r a l o s c o e f i c i e n t e s t r i a n g u l a r i n f e r i o r
end
B( i )=B( i )− f f ∗B( k ) ; %c a l c u l a l o s t i m o d i f i c a d o s
end
end
##paquete de s i s t i t u c i o n h a c i a a t r a s para r e s o l v e r e l s i s t e m a
X=z e r o s ( n , 1 ) ; %c r e a un v e c t o r para l a s i n c o g n i t a s
X( n)=B( n ) /A( n , n ) ; %c a l c u l a l a i n c o g n i t a de l a u l t i m a f i l a
%de l a m a t r i z t r i a n g u l a r
f o r i=n−1: −1:1
sum=B( i ) ;
f o r j=i +1:n
sum=sum−A( i , j ) ∗X( j ) ;
end
X( i )=sum / (A( i , i ) ) ;
end

d i s p l a y ( ” Elemento p i v o t ” ) ;
A( 1 , 1 )
display (””);
d i s p l a y (” matriz A t r i a n g u l a r i z a d a superiormente ” ) ;
A
display (””);
d i s p l a y ( ” v e c t o r columna de t e r m i n o s i n d e p e n d i e n t e s primos ” ) ;
B
display (””);
d i s p l a y ( ” v e c t o r de i n c o g n i t a s ” ) ;
X
pause
pause

c) main gauss
##main g a u s s
#
##
tic
clear all
clc
format l o n g
##Datos
A=l o a d ( ’ H i l b e r t m a t r i x 2 . txt ’ ) ;
%l o a d ( ’A. txt ’ ) ; %D e f i n e l a m a t r i z de c o e f i c i e n t e s dato A
A
B=A∗ [ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ] ’ ;

3
 %l o a d ( ’B . txt ’ ) ; %D e f i n e m a t r i z de t e r m i n o s i n d p t e s .

B
%Dimension d e l s i s t e m a de e c u a c i o n e s l i n e a l e s
n=l e n g t h (B ) ;
X=z e r o s ( n , 1 ) ; %c r e a un v e c t o r para l a s i n c o g n i t a s

d i s p l a y ( ’ Uso de memoria d e b i d o a l o s d a t o s en Mbytes ’ ) ;

RAM A=8∗n . ˆ 2 / 1 0 2 4
RAM B=8∗n /1024
RAM X=8∗n /1024

display ( ’ ’);

%T o l e r a n c i a d e f i n i d a para e l p i v o t e o e s c a l a d o
t o l =1e −6;

%V a r i a b l e bandera de e r r o r
e r =0;

## Bucle de busqueda d e l e l e m e n t o de mayor norma de l a m a t r i z A

f o r i =1:n
s ( i )=norm (A( i , 1 ) ) ;
f o r j =2:n
i f norm (A( i , j ))> s ( i )
s ( i )=abs (A( i , j ) ) ;
endif
end
end
##C a l l e l i m i n a t e
[ A, B]= g a u s s e l i m i n a t e (A, B, s , n , t o l , e r ) ;
i f e r != −1
[ A, B,X]= g a u s s s u b s t i t u t e (A, B, n ,X)
end
toc
c s v w r i t e ( ’ M a t r i z d e i n c o g n i t a s 4 . txt ’ , X ) ; #Genera un a r c h i v o de s a l i d a
#con l o s c o e f i c i e n t e s i n c o g n i t a b u s c a d o s

d) gauss eliminate (subrutina de eliminación hacia adelante, llamada en la ruti-

na principal ”main gauss”)
f u n c t i o n [ A, B]= g a u s s e l i m i n a t e (A, B, s , n , t o l , e r )
f o r k=1:n−1

4
 [ A, B, s ]= g a u s s p i v o t e (A, B, s , n , k ) ;
i f abs (A( k , k ) / s ( k))< t o l
e r =−1;
e r r o r ( ’ m a t r i z s i n g u l a r , f i n de c a l c u l o ’ ) ;
break
endif

#e l b u c l e f o r i g e n e r a r a l a f i l a de l a m a t r i z t r i a n g u l a r , en f u n c i o n
#a l a e l e m i n a c i o n , a r r a n c a d e s d e l a 2da f i l a d e b i d o a que l a p r i m e r a
#f i l a e s l a d e l p i v o t
f o r i=k+1:n
# f f e s e l f a c t o de p i v o t e o , en f u n c i o n a l e l e m e n t o A( k , k ) , e s t e i r a
# m o d i f i c a n d o s e cuando e l p r o c e s o de e l i m i n a c i o n
f f =A( i , k ) /A( k , k ) ;
# e l b u c l e f o r j , g e n e r a r a l a s columnas de l a m a t r i z t r i a n g u l a r , a l s e r l a
# m a t r i z t r i a g u n l a r e l e l e m e n t o A( 2 , 1 ) ya no e x i s t e en l a segunda f i l a por
# eso j arranca desde 2
f o r j=k+1:n
A( i , j )=A( i , j )− f f ∗A( k , j ) ; %aca s e r e s t a n l o s a22− f f ∗ a21 , s u c e s i v a m e n t e
%cambian de sub i n d i c e s , s e g e n e r a r a n a22 ’
A( i , k)=A( i , k)−A( i , k ) ; %a c e r a l o s c o e f i c i e n t e s t r i a n g u l a r i n f e r i o r
endfor
B( i )=B( i )− f f ∗B( k ) ; %c a l c u l a l o s t i m o d i f i c a d o s
endfor
endfor
i f abs (A( k , k ) / s ( k))< t o l
e r =−1;
endif
endfunction

e) gauss pivote (subrutina de cambio de elemento pivot y renglón llamada como

subrutina en ”gauss eliminate” )
##g a u s s p i v o t e
f u n c t i o n [ A, B, s ]= g a u s s p i v o t e (A, B, s , n , k )
p=k ;
b i g=abs (A( k , k ) / s ( k ) ) ;
f o r i i =k+1:n
dummy=abs (A( i i , k ) / s ( i i ) ) ;
i f dummy > b i g
b i g=dummy ;
p= i i
endif
endfor
i f p !=k
f o r j j =k : n

5
 dummy=A( p , j j ) ;
A( p , j j )=A( k , j j ) ;
A( k , j j )=dummy ;
%A
%pause
endfor
dummy=B( p ) ;
B( p)=B( k ) ;
B( k)=dummy ;
%B
%pause
dummy=s ( p ) ;
s ( p)= s ( k ) ;
s ( k)=dummy ;
%s
%pause
endif
endfunction

f) gauss substitute Esta subrutina es la encargada de despejar las incógnitas

buscadas en este caso el vector X, mediante X=B/A.
##g a u s s s u s t i t u t e
f u n c t i o n [ A, B,X]= g a u s s s u b s t i t u t e (A, B, n ,X)
X( n)=B( n ) /A( n , n ) ; %c a l c u l a l a i n c o g n i t a de l a u l t i m a
%f i l a de l a m a t r i z t r i a n g u l a r
f o r i=n−1: −1:1
sum=0;
f o r j=i +1:n
sum=sum+A( i , j ) ∗X( j ) ;
end
X( i )=(B( i )−sum ) /A( i , i ) ;
end
endfunction

El código principal inserta los datos de las matrices A y B, mediante archivos

de textos generados por una copia de los .pdf de los ejercicios o mediante un
archivo excel, guardando como .scv también serı́a posible en caso de contar con
matrices de dimensiones considerables.

1.2. Matriz de Hilbert y sistemas mal condicionados

a) matriz de coeficientes A, vector de términos independientes B y vector de
incógnitas X

6
 Matriz A
3.0 −0.1 −0.2
0.1 7.0 −0.3
0.3 −0.2 10.0

Vector B
7.85
−19.3
71.4

Vector C - Incógnitas
3
−2.5
7.000000000000002

Los resultados son iguales comparando con los aportados por el ejemplo 9.5
del libro de Chapra, inclusive con menor error al utilizar ”format long”.
Se han agregado sobre al código principal, unas lı́neas para determinar el
tamaño en memoria RAM de los datos de ingreso, y el tiempo de duración
por la ejecución del código.
b) Para crear las matrices de Hilbert se ha utilizado el siguiete algoritmo, el cual
genera un archivo de salida en .txt, que servirá luego de entrada de datos
para el main gauss.

Código Matriz de Hilbert

n =10; #d i m e n s i o n de l a m a t r i z d e s e a d a
f o r i =1:n
f o r j =1:n
H( i , j )=1/( i+j − 1 ) ;
end
end
H
c s v w r i t e ( ’ H i l b e r t m a t r i x 2 . t x t ’ , H) ; #a r c h i v o de s a l i d a ,
# con d e s t i n o en e l path

Matriz resultado H del Código separadas con comas.

1 ,0.5 ,0.3333333333333333
0.5 ,0.3333333333333333 ,0.25
0.3333333333333333 ,0.25 ,0.2

[A] = [H]
[X] = [1, 1, 1]T
[B] = [A]{X} = [1,833333333333333; 1,083333333333333; 0,783333333333333]T

7
 Para la H3x3 Se define un error como una resta entre los elementos del
vector unitario dado [X] = [1, 1, 1]T y del vector [X] obtenido mediante
el código de gauss main.

[X]gaussmain

0.9999999999999984
1.00000000000001
0.99999999999999

error = {1, 1, 1}T − [X]gaussmain

 
1,55431223447522e − 15
error =  −9,54791801177635e − 15 
9,99200722162641e − 15

Los errores están truncandos en un orden elevado (”debido al format

long”), lo cual se puede llegar a la conclusión que el código realiza de
manera efectiva el escalamiento y la definición del pivote.

c) Hilbert de 7x7

[X]gaussmain

0.9999999999932647
1.000000000265063
0.9999999974720412
1.000000009752828
0.9999999822278254
1.000000015282108
0.9999999950024648

error = {1, 1, 1, 1, 1, 1, 1}T − [X]gaussmain

 
6,73527900119097e − 12

 −2,65063082593997e − 10 


 2,52795884225776e − 09 

error = 
 −9,75282765658392e − 09 


 1,77721746208448e − 08 

 −1,52821080234844e − 08 
4,99753516347567e − 09

8
d) Hilbert de 10x10
El sistema se define como mal condicionado, saliendo del cálculo desde la sub-
rutina ”gauss eliminate”, lo cual genero como condición mediante la sentecia
error luego de pasar la variable bandera er = −1.

2. Descomposición LU
2.1. Código.m
El código utilizado es el presentado en la guı́a, con la diferencia que a cada
”function”, se la dividió en módulos .m, donde son archivos de subrutinas que
se llaman desde un archivo principal ”luchapra main.m”. A continuación se
presenta el archivo principal.
##D e s c o m p o s i c i o n LU c u e r p o p r i n c i p a l d e l c o d i g o
tic
format l o n g
a=l o a d ( ’ H i l b e r t m a t r i x 2 . txt ’ ) ;
%l o a d ( ’ a . txt ’ ) ; # m a t r i z c o e f i c i e n t e de d a t o s
b=a ∗ [ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ] ’ ;
%l o a d ( ’ b . txt ’ ) ; # v e c t o r de d a t o s t e r m i n o s i n d p t e s
t o l =1e −6;
[m, n]= s i z e ( a ) ;
o=z e r o s ( 1 , n ) ;
s=z e r o s ( 1 , n ) ;
e r =0;

[ a , o]= decompose ( a , n , t o l , o , s , e r ) ;

i f e r != −1;
##s i n o s e ha d e t e c t a d o una m a t r i z s i n g u l a r en decompose , s e
##r e a l i z a s u s t i t . :
x=s u b s t i t u t e ( a , o , n , b ) ’
c s v w r i t e ( ’ M a t r i z d e i n c o g n i t a s 2 . txt ’ , x ) ; #Genera un a r c h i v o de s a l i d a
#con l o s c o e f i c i e n t e s i n c o g n i t a b u s c a d o s

else
error ( ’ singularmatrixdetected ’ ) ;
endif
%e n d f u n c t i o n %f u n c i o n 1
toc

a) [a]
3.0 −0.1 −0.2
0.1 7.0 −0.3
0.3 −0.2 10.0

9
 {b}

7.85
−19.3
71.4

Vector {X} de incógnitas

0.9999999999999973
1.000000000000017
0.9999999999999826

b) Matriz de Hilbert de 3x3

El proceso sigue la misma descripción algebraica que para el punto 1.2, la
matriz [H] = [A], y el vector {b} = A · {1, 1, 1}. Donde {x} = [1, 1, 1]T
 
0,999999999999997
xLU =  1,000000000000017 
0,999999999999983

c) Matriz de Hilbert de 7x7

 
0,999999999995465

 1,000000000182967 


 0,999999998224407 

xLU =
 1,000000006939262 


 0,999999987227655 

 1,000000011071011 
0,999999996355802

d) Matriz de Hilbert de 10x10

Nuevamente el sistema sale por mal condicionamiento de la matriz de Hilbert
de 10x10 lo hace en la subrutina ”decompose” en la lı́nea 22.

2.2. Matriz inversa

Al código original de LU, se le agrega una función ”inverse”, y se anula el
proceso de substitución.
clear all
clc
tic
a=l o a d ( ’ H i l b e r t m a t r i x 1 0 x 1 0 . txt ’ ) ;
%l o a d ( ’ a . txt ’ ) ;
b=a ∗ [ 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 ] ’ ;

10
%l o a d ( ’ b . txt ’ ) ;
t o l =1e −6;
[m, n]= s i z e ( a ) ;
o=z e r o s ( 1 , n ) ;
s=z e r o s ( 1 , n ) ;
e r =0;

[ a , o]= decompose ( a , n , t o l , o , s , e r ) ; %Obtengo l a m a t r i z [U]

a i=i n v e r s e ( a , n , t o l , o , s , e r ) ; %I n v i e r t e l a m a t r i z

toc

#No s e r e a l i z a l a s u s t i t u c i o n porque s e busca l a m a t r i z

#i n v e r s a para l u e g o h a c e r l a o p e r a c i o n b a r r a i n v e r t i d a
%i f e r != −1;
##s i n o s e ha d e t e c t a d o una m a t r i z s i n g u l a r en #decompose , s e r e a l i z a s u s t i t . :
%x=s u b s t i t u t e ( a , o , n , b ) ;
%e l s e
%e r r o r ( ’ s i n g u l a r m a t r i x d e t e c t e d ’ ) ;
%e n d i f
%e n d f u n c t i o n %f u n c i o n 1

a)  
3,0 −0,1 −0,2
A =  0,1 7,0 −0,3 
0,3 −0,2 10,0

Del Octave GNU, mediante la funcion ”inv()”.

 
0,33248872133984303 0,00494407020579692 0,00679809653297077
Ainv =  −0,00518176588876793 0,14290264460216873 0,00418344402028970 
−0,01007829695797065 0,00270973078586947 0,09987972598441668

Del código LU presentado

 
0,33248872133984303 0,00494407020579692 0,00679809653297077
AinvLU =  −0,00518176588876793 0,14290264460216873 0,00418344402028970 
−0,01007829695797065 0,00270973078586947 0,09987972598441668

Diferencia entre la matriz inversa ofrecida por el comando inv() del Octave
y el del código
 
5,55111512312578e − 17 0,00000000000000e + 00 0,00000000000000e + 00
error =  0,00000000000000e + 00 2,77555756156289e − 17 0,00000000000000e + 00 
0,00000000000000e + 00 −4,33680868994202e − 19 0,00000000000000e + 00

11
b) Matriz de Hilbert de 3x3
 
1 0,5 0,3333333333333333
H= 0,5 0,3333333333333333 0,25 
0,3333333333333333 0,25 0,2

Del inv() Octave

 
9,00000000000003 −36,00000000000014 30,00000000000013
Hinv =  −36,00000000000014 192,00000000000074 −180,00000000000068 
30,00000000000013 −180,00000000000068 180,00000000000063

Con el código lu chapra main inv

 
9,000000000000005 −36 30
HinvLU =  −35,99999999999999 191,9999999999998 −179,9999999999997 
29,99999999999997 −179,9999999999997 179,9999999999997

 
−2,13162820728030e − 14 1,42108547152020e − 13 −1,31450406115619e − 13
error =  1,49213974509621e − 13 −9,37916411203332e − 13 9,94759830064140e − 13 
−1,59872115546023e − 13 9,94759830064140e − 13 −9,37916411203332e − 13

c) Matriz de Hilbert de 7x7

Por comodidad debido a las dimensiones de la matriz de Hilbert en este
punto solo se referirán a ellas con el nombre de los archivos disponibles en
archivo .zip que se realiza con la entrega del TP.
Matriz de H7x7
Hilbert matrix7x7.txt
Matriz inversa
HinvLU
Matriz inversa ai2.txt
El error máximo entre la matriz inversa calcula por el octave inv() y la
calculada con el código ”luchapra main inv.m”
Posee una diferencia máxima de 0,0530172288417816, y una mı́nima de 1,39435059054449e−
08.

d) La matriz de Hilbert de 10x10, sigue siendo la misma que sale del cálculo
en la subrutina ”decompose”, por lo tanto esta es una matriz singular y se
detiene el cálculo.

12