Métodos Numéricos Ingeniería Aeronáutica

Andrs Zarabozo
Mtodos Numricos. Apuntes
Ingeniera Aeronutica
ETSEIAT
2012
Andrs Zarabozo Martnez
Mtodos numricos
Acerca de estos apuntes

Estos apuntes se han realizado para cubrir el temario de la asignatura mtodos numricos,
que se imparte en el quinto curso de Ingeniera Aeronutica en la Escola Tcnica Superior
dEnginyeries Industrial i Aeronutica de Terrassa, de la Universitat Politcnica de Catalunya
(ETSEIAT UPC).
Licencia
Esta obra est bajo una licencia Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0) de
Creative Commons. Para ver una copia de esta licencia, visite:
http://creativecommons.org/licenses/by-sa/3.0/deed.es_ES
En lneas generales:
Es libre de:
Compartir Copiar, distribuir y comunicar pblicamente la obra.

Transformar la obra y crear obras derivadas.
Hacer un uso comercial de esta obra.
Bajo las condiciones siguientes:
Reconocimiento Debe reconocer al autor de la obra original (pero no de una

manera que sugiera que tiene su apoyo o apoya el uso que hace de su obra).
Compartir bajo la Misma Licencia Si altera o transforma esta obra, o genera una
obra derivada, slo puede distribuir la obra generada bajo una licencia idntica a sta.
-2-
Mtodos numricos
ndice
1.
Programacin en Fortran
1.1.
Tipos de variables .......................................................................................................... 7
1.2.
Expresiones aritmticas ................................................................................................ 7
1.3.
Bucles y condiciones ..................................................................................................... 8
1.4.
Vectores y matrices ....................................................................................................... 9
1.5.
Subrutinas ................................................................................................................... 11
1.6.
Lectura y escritura de datos ........................................................................................ 12
1.7.
Programas ................................................................................................................... 13
Programa 1. Mnimo error de un tipo de variable .............................................................. 13

Programa 2. Clculo del nmero ...................................................................................... 15
2.
Interpolacin
2.1.
SPLINE.......................................................................................................................... 17
2.2.
Interpolacin cbica en un solo intervalo ................................................................... 18
2.3.
Programa ..................................................................................................................... 20
Programa 3. Entrada de datos e interpolacin ................................................................... 20

3.
Integracin
3.1.
Frmula de Newton-Cotes .......................................................................................... 23
3.2.
Regla del punto medio ................................................................................................ 25
3.3.
Regla del trapecio ........................................................................................................ 25
3.4.
Regla de Simpson ........................................................................................................ 27
3.5.
Extrapolacin de Richardson ....................................................................................... 28
3.6.
Programas ................................................................................................................... 30
Programa 4. Obtencin de la serie de Fourier .................................................................... 30
Programa 5. Iteraciones y extrapolacin ............................................................................ 33

4.
Resolucin numrica de ecuaciones no lineales

4.1.
Mtodo de la biseccin ............................................................................................... 36
4.2.
Mtodo de Newton - Raphson .................................................................................... 36
4.3.
Mtodo de la secante.................................................................................................. 37
4.4.
Mtodo de regula falsi ................................................................................................ 38
4.5.
Teorema del punto fijo................................................................................................ 39
4.6.
Programas ................................................................................................................... 41
-3-
Mtodos numricos
Programa 6. Deflexin de un cable ..................................................................................... 41

Programa 7. Resolucin mediante Newton-Raphson ......................................................... 44
5.
Resolucin numrica de sistemas lineales

5.1.
Mtodo de eliminacin de Gauss................................................................................ 45
5.2.
Matrices mal condicionadas........................................................................................ 46
5.3.
Descomposicin LU ..................................................................................................... 47
5.4.
Doolittle ....................................................................................................................... 47
5.5.
Crout ............................................................................................................................ 48
5.6.
Matrices dispersas....................................................................................................... 49
5.7.
Mtodo del gradiente conjugado................................................................................ 51
5.8.
Ejemplo de aplicacin del mtodo del gradiente conjugado ...................................... 56
5.9.
Programas ................................................................................................................... 58
Programa 1. Resolucin de un sistema mediante Gauss .................................................... 58

Programa 2. Sistema con matriz mal condicionada ............................................................ 61
Programa 3. Doolitle ........................................................................................................... 64
Programa 4. Crout ............................................................................................................... 66
Programa 5. Matriz banda................................................................................................... 69
6.
Resolucin numrica de sistemas no lineales

6.1.
7.
Mtodo de Newton para sistemas no lineales............................................................ 72
Ecuaciones diferenciales, problemas de valor inicial

7.1.
Tipos de ecuaciones diferenciales ............................................................................... 74
7.2.
Mtodo de Euler.......................................................................................................... 74
7.3.
Ejemplo de resolucin mediante el mtodo de Euler. ................................................ 75
7.4.
Mtodo implcito de Euler........................................................................................... 75
7.5.
Mtodo de Heun ......................................................................................................... 76
7.6.
Mtodo de Runge-Kutta de segundo orden ............................................................... 77
7.7.
Mtodo de Runge-Kutta de rdenes superiores......................................................... 78
7.8.
Mtodo adaptativo de Runge-Kutta ........................................................................... 80
7.9.
Esquema de Crank-Nicolson........................................................................................ 81
7.10. Mtodo de Runge-Kutta para EDOs de grados superiores ......................................... 81

8.
Mtodo de diferencias finitas

8.1.
Diferencias finitas en una dimensin. ......................................................................... 82
8.2.
Diferencias finitas en dos dimensiones ....................................................................... 83
-4-
Mtodos numricos
8.3.
Ejemplo de problema mecnico.................................................................................. 84
8.4.
Programas ................................................................................................................... 90
Programa 6. Ejemplo de problema mecnico ..................................................................... 90

9.
Mtodo de elementos finitos

9.1.
Forma fuerte del problema ......................................................................................... 96
9.2.
Mtodo de Rayleigh-Ritz y mtodo de Galerkin ......................................................... 96
9.3.
Ejemplo de formulacin fuerte para problema estructural ........................................ 97
9.4.
Funciones de forma ................................................................................................... 100
9.5.
Cuadratura de Gauss ................................................................................................. 101
9.6.
Tipos de elementos en 2D ......................................................................................... 101
9.7.
Ejemplo de problema trmico................................................................................... 105
9.8.
Programa ................................................................................................................... 111
Programa 7. Radiador espacial .......................................................................................... 111

10. Apndice
10.1. Programacin en Fortran .......................................................................................... 123
Programa 1. Mnimo error de un tipo de variable ............................................................ 123
Programa 2. Clculo del nmero .................................................................................... 124
10.2. Interpolacin ............................................................................................................. 125
Programa 3. Entrada de datos e interpolacin ................................................................. 125
10.3. Integracin ................................................................................................................ 127
Programa 4. Obtencin de la serie de Fourier .................................................................. 127
Programa 5. Iteraciones y extrapolacin .......................................................................... 129
10.4. Resolucin numrica de ecuaciones no lineales ....................................................... 131
Programa 6. Deflexin de un cable ................................................................................... 131
Programa 7. Resolucin mediante Newton-Raphson ....................................................... 132
10.5. Resolucin numrica de ecuaciones lineales ............................................................ 133
Programa 8. Resolucin de un sistema mediante Gauss .................................................. 133
Programa 9. Sistema con matriz mal condicionada .......................................................... 134
Programa 10. Doolittle ...................................................................................................... 136
Programa 11. Crout ........................................................................................................... 138
Programa 12. Matriz Banda .............................................................................................. 140
10.6. Mtodo de diferencias finitas ................................................................................... 142
Programa 13. Ejemplo de problema mecnico ................................................................. 142
-5-
Mtodos numricos
10.7. Mtodo de elementos finitos.................................................................................... 145

Programa 15. Radiador especial........................................................................................ 145
10.8. Datos de entrada del Programa 13, radiador espacial .............................................. 154
-6-
Mtodos numricos
1. Programacin en Fortran
1.1.
Tipos de variables
En Fortran se suelen usar cinco tipos bsicos de variables:
Boolean:
Es una variable de un solo bit y por lo tanto solo puede tener dos posibles valores
(.true. o .false.).
Integer:
Solo permite tener un valor enteros, en general ocupa
bits. El primer bit contiene el
signo y por lo tanto el mdulo del nmero ocupa los restantes
bits. El valor mximo
es igual a
.
Real:
Es similar al Double usado en otros lenguajes de programacin como C. Permite
nmeros en decimales y en general ocupa
bits. De forma similar al Integer el primer
bit contiene el signo del nmero.
Complex:
Son nmeros complejos compuestos de dos nmeros Real separados por una coma y
entre parntesis. El primer nmero representa el valor real y el segundo el valor
complejo.
Character:
Se utiliza para escribir letras. Se suele generar un vector donde cada posicin es un
caracter.
Para definir una variable se debe declarar primero el tipo y luego el nombre de la variable. Las
variables tienen que tener un nombre entre y
letras o nmeros siendo la primera siempre
una letra. En Fortran no hay diferencia entre maysculas y minsculas.
real x
integer i
Tambin se puede definir el tamao en memoria de las distintas variables como por ejemplo:
real*8 x
integer*8 i
1.2.
Expresiones aritmticas
Las cinco operaciones aritmticas bsicas son: la suma (+), la resta (-), la multiplicacin (*), la
divisin (/) y el exponente (**). Fortran tambin reconoce otro tipo de funciones como por
ejemplo funciones trigonomtricas, logaritmos Las operaciones aritmticas devuelven un
resultado (que puede ser un Real o Integer) y debe ser almacenado en una variable.
-7-
Mtodos numricos
x = 1. + 3. 25 * 5. / 3.
x = cos(1.25) + y**2.
El orden de las operaciones es:
Primero:
Todas las operaciones exponenciales y se desarrollan de derecha a izquierda.
Segundo:
Todas las multiplicaciones y divisiones, el orden es de izquierda a derecha.
Tercero:
Todas las operaciones de suma y resta, el orden es de izquierda a derecha.
En este libro se va a centrar el estudio del uso de Fortran para aplicacin en mtodos
numricos. Los programas se deben escribir de forma ptima para el clculo. La latencia es el
tiempo que se consume en una operacin. Las operaciones bsicas (menos los exponentes)
tienen latencias muy bajas, en especial la suma, la resta y la multiplicacin. La divisin tiene
una latencia un poco ms alta aunque en los nuevos procesadores como por ejemplo los Intel
i7 la diferencia en latencia es despreciable, en ordenadores antiguos la latencia puede ser
hasta cinco veces ms lenta. Las operaciones exponenciales, trigonomtricas, logartmicas
son demasiado lentas y deben ser evitadas en la medida de lo posible. Por ejemplo si se quiere
calcular la siguiente ecuacin:
( )
(1.1)
Se debera evitar hacer la operacin exponente y se podra escribir de la siguiente forma (la
terminologa de los bucles en Fortran se explica ms adelante).
p = a(n)
do i .eq. n, 1, -1
p = p * x + a (n - 1)
end do
1.3.
Bucles y condiciones
El bucle estndar en Fortran es do. Se le da un valor inicial a una variable Integer y se le

define el valor final. El cdigo que se ejecuta en el bucle se debe finalizar con end do.
do i .eq. 1, 10, 2
x=x+i
end do
-8-
Mtodos numricos
Por defecto cada vez que se ejecuta el bucle se le suma uno a la variable (en el ejemplo i) pero
se puede cambiar el valor que se aade poniendo despus del valor final una coma y el
sumando.
La funcin if ejecuta solo el cdigo si se cumple la condicin impuesta. Para poner condiciones
en Fortran se utiliza la siguiente sintaxis (abreviaciones del ingls):
-
Mayor que: .gt.

Menor que: .lt.
Mayor o igual a: .ge.
Menor o igual a: .le.
Igual a: .eq.
Diferente de: .ne.
Se puede complementar la funcin if utilizando las funciones else (si la condicin del if no se
cumple se ejecuta el cdigo que sigue al else) o elseif (parecido al else pero se le aade una
condicin ms para que se ejecute el cdigo). Se pueden poner tantos elseif como se quieran
en un mismo conjunto de if. Se debe finalizar el cdigo de esta funcin con endif.
if (a .gt. 2) then
b=1
else
b=0
end if
La funcin do while ejecuta repite el cdigo hasta que la condicin deje de cumplirse. El
cdigo dentro del do while se ejecuta hasta que se finaliza (con end do) y vuelve a la lnea del
principio para comprobar si se cumple an la condicin. Si se desea salir del bucle en algn
punto intermedio se puede utilizar la funcin exit.
do while (a .lt. 5)
a=a+1
end do
1.4.
Vectores y matrices
Se usan los vectores y matrices para utilizar un solo nombre que refiera a un conjunto de
direcciones de memoria. Todos los datos almacenados en un vector o una matriz deben ser del
mismo tipo.
Para usar un vector o matriz (a partir de ahora solo se referirn a matrices ya que el
funcionamiento es casi el mismo) se debe primero declralo. Se puede declarar de forma
esttica o de forma dinmica. Si se declara de forma dinmica no se define la dimensin de la
matriz, mientras que si se define de forma esttica si que se define la dimensin.
-9-
Mtodos numricos
Para declarar una matriz de forma esttica se pone el tipo de las variables que almacena
seguido del nombre de la matriz y en parntesis sus dimensiones, se utiliza una coma para
definir las distintas columnas de la matriz (el valor de la dimensin de cada columna debe ser
un integro).
real a(4,9)
integer b(2,n)
Para declarar una matriz de forma dinmica se debe utilizar el parmetro allocatable y utilizar
dos puntos para las columnas que no se quiere definir la dimensin. Una vez se decide dar un
valor a la dimensin se utiliza la funcin allocate.
real, allocatable : : a(4, :)
integer n
print*,"Dimensions of the matrix?"
read(*,*) n
allocate(a(:,n))
Una matriz creada de forma dinmica puede ser eliminada (para liberar espacio en la
memoria) con la funcin dellocate. Para saber si una matriz dinmica est creada o no en un
momento dado se puede usar la funcin intrnseca allocatable (la funcin devuelve un valor
booleano).
Las tablas se puede utilizar globalmente, referenciando un conjunto de elementos seguidos o
de forma individual. Si solo se indica el nombre de la matriz se referencia todos los elementos.
Para referenciar un valor especfico se debe introducir la posicin del valor de la matriz. Si se
quiere referenciar un rango se utiliza el doble punto para delimitar el rango.
real M(2,4), V(3)
V(2) = 1.
M(2,2:4) = V(2)
En el ejemplo anterior se introduce el valor de V(2) (es decir ) en los tres valores de la matriz
M (M(2,2), M(2,3), M(2,4)).
Las operaciones que se pueden hacer con matrices son:
x * M: Multiplicacin de cada elemento de una matriz M y un escalar x.

x + M: Suma de cada elemento de una matriz M y un escalar x.
M * M: Multiplicacin de cada elemento por su homologo elemento entre dos
matrices de misma dimensin.
- 10 -
Mtodos numricos
traspose(M): Transpuesta de una matriz.

matmul(M,M): Multiplicacin matricial entre dos matrices.
dot_product(V,V): Producto escalar entre dos vectores.
Las matrices se almacenan en direcciones consecutivas de memoria. En el caso de un vector

los valores se almacena secuencialmente, empezando por el primero del vector V(1) hasta el
ltimo valor V(n).
V(1)
V(2)
V(3)
V(n-1)
V(n)
Figura 1.1. Orden de los valores de un vector en la memoria.

En el caso de matrices, los valores se almacenan por columnas. Por ejemplo si se tiene una
matriz M(2,2,2) el orden en la memoria es:
M(1,1,1)
M(2,1,1)
M(1,2,1)
M(2,2,1)
M(1,1,2)
M(2,1,2)
M(1,2,2)
M(2,2,2)
Figura 1.2. Orden de los valores de una matriz en la memoria.
1.5.
Subrutinas
Las subrutinas o subroutine son como funciones en otros lenguajes de programacin. Se crea
una subrutina de la misma forma que el programa principal, con la nica diferencia que se
deben poner las variables de referencia que se le quieren pasar a la subrutina.
Es recomendable definir al principio de la rutina si la variable es de entrada o de salida. De esta
forma el compilador puede informar de errores en el programa, si por ejemplo se le intenta
dar un valor a una variable de entrada.
En las subrutinas las variables se envan como referencia, es decir, se enva la direccin de
memoria de la variable. Si la variable es una matriz se enva la direccin del primer valor de la
matriz.
subroutine areaCircle(A, r)
implicit none
real, intent (in) :: r
real, intent (out) :: A
real, parameter :: pi = acos(-1)
A = pi * r * r
end subroutine
La subrutina de ejemplo calcula el rea de un crculo. El valor de entrada es el radio y devuelve

el rea. Para llamar a la subrutina se utiliza la funcin call.
real A1, r1
r1 = 3.
call areaCircle(A1, r1)
- 11 -
1.6.
Mtodos numricos
Lectura y escritura de datos
Cuando se quiere trabajar con un archivo para leer o escribir datos se debe usar la funcin
open. Se le asigna un nmero de unidad al archivo abierto que es el identificador. Dentro de la
funcin se debe definir el archivo y el acceso. El acceso se puede definir por ejemplo como
secuencial, es decir, que cada vez que se escriba o se lea pasa a la siguiente lnea. Para el
archivo se debe introducir la ruta completa o bien si el archivo est en la misma carpeta se
puede simplemente poner el nombre.
Para leer un archivo se debe utilizar la funcin read, seguido de una variable o matriz en
donde se quiera almacenar los datos de lectura. Para escribir se usa write seguido de las
variables o los datos que se quieren introducir.
Una vez se termina de usar el archivo es conveniente cerrarlo usando close.
open(unit = 1, file='fileData', access='SEQUENTIAL')
read(1,*) n
write(1,*) 2 * n
close(1)
- 12 -
1.7.
Mtodos numricos
Programas
Programa 1. Mnimo error de un tipo de variable

El primer programa sirve de ejemplo para poder ver un poco como funcionan los programas
escritos en Fortran.
El objetivo es calcular el mnimo valor para un tipo de variable. Se utilizan variables real ya que
no tiene sentido hacerlo con integer (el error sera ). Se busca el menor nmero tal que
. En Fortran existe una funcin intrnseca que calcula lo mismo y que se llama
epsilon().
Como todo programa se debe empezar declarando el programa y las variables que se van a
utilizar. Se necesita al menos una variable donde se pueda almacenar el resultado deseado
(dndole un valor inicial) y tambin se necesita una variable para el bucle que se va a realizar.
program program1
implicit none
integer i
Small = 1.
end program
El bucle que se quiere realizar consiste en ir dividiendo por dos el valor de la variable small e ir
comprobando que se cumpla la ecuacin
. Se elige en este ejemplo un bucle tipo do
pese a que sera ms lgico utilizar un bucle while, de esta forma se puede ver como funciona
tambin la condicin if.
Dentro de cada iteracin se debe comprobar que se cumpla la ecuacin descrita, y si se cumple
se debe dividir el valor del resultado por dos. En caso de que no se cumpla la condicin hay
que salir de bucle utilizando exit.
do i = 1, 1000
if (1. + small .gt. 1.) then
small = 0.5 * small
else
exit
end if
end do
El resultado an no es exactamente el valor almacenado en small, el valor bueno es el
resultado multiplicado por dos. Para poder ver el valor en pantalla se usa la funcin print*,. Se
puede tambin utilizar la funcin epsilon(small) para poder comparar el resultado.
- 13 -
Mtodos numricos
small = 2 * small
print*, small
print*, epsilon(small)
Se puede cambiar el tipo de variable cuando se define esa, pudiendo probar con variables con
ms precisin.
real*8 small8
real*16 small16
- 14 -
Mtodos numricos
Programa 2. Clculo del nmero

Utilizando solo una cuerda de
y un cuadrado de
se puede calcular el nmero . Se
dibuja un cuarto de crculo de radio un metro dentro del cuadrado y se van lanzando bolas
sobre el cuadrado. Estadsticamente el nmero de bolas dentro de cada zona es proporcional
al rea. El rea de un cuarto de crculo es:
(1.2)
Siendo el nmero de bolas totales lanzadas y
crculo, la relacin entre y es:
el nmero de bolas que caen en el cuarto de
Por lo tanto el nmero
(1.3)
es igual a:
(1.4)
Para obtener un nmero aleatorio se utiliza la funcin random_number(). De esta forma se

simboliza que se lanza una bola y aleatoriamente cae en una posicin concreta del cuadrado.
Como en todos los programas lo primero que se hace es declarar el programa y las variables.
Para obtener mayor precisin se utilizan variables con double precision. Se necesitan cuatro
variables. Dos variables e para definir la posicin donde cae la bola, se podra tambin
utilizar un vector. Y luego dos variables que definan el nmero de bolas totales y las que han
cado dentro de cuarto de crculo.
program program2
implicit none
real*8 x, y
integer*8 total, inside
total = 0
inside = 0
Se debe empezar el proceso iterativo mediante un bucle. Se muestra a continuacin otra

forma de hacer bucles. Se utiliza la funcin continue y la funcin go to. La segunda debe
tener un nmero integro para que el compilador sepa a donde tiene que ir.
El primer paso del bucle es generar la posicin aleatoria y sumarle un valor al nmero total de
bolas lanzadas.
Una vez se lanza la bola se debe comprobar si cae dentro del cuarto de crculo. Como el centro
del eje de coordenadas se define en el centro del circulo se debe cumplir que
.
- 15 -
Mtodos numricos
Lo siguiente ya es calcular el valor de . Como las iteraciones se hacen muy rpido se puede
marcar que muestre el valor de cada cierto nmero de iteraciones. La funcin mod(x,y)
devuelve el resto de la divisin de ntegros.
Hay que acordarse de que siempre que se hace un clculo con variables de diferentes tipos se
deben convertir al tipo de la variable que se est calculando. Esto puede evitar errores de
clculos que no son detectados por el compilador. En este problema, como se han calculado
las variables con double precision se deben convertir con la funcin dble().
10 continue
!Ball thrown
call random_number(x)
call random_number(y)
total = total + 1
!Looks where the ball fell
if(x*x + y*y .lt. 1.) inside = inside + 1
!Shows the result every 1000 iterations
if (mod(total, 1000) .eq. 0) then
print*, total, 4. * dble(inside) / dble(total)
end if
go to 10
end program
Este programa tiene un bucle que nunca finaliza, hay que tener cuidado con este tipo de
bucles ya que, pese a que en este programa esto no afecta al resultado, en otro programa ms
complicado puede meterse en un bucle infinito y no calcular nada. Con este tipo de bucles se
puede salir utilizando la funcin exit normalmente dentro de un if.
- 16 -
Mtodos numricos
2. Interpolacin
2.1.
SPLINE
En anlisis numrico, un spline es una curva diferenciable definida en porciones mediante

polinomios. Esto es til para poder generar curvas en funciones donde se tienen una serie de
puntos definidos o tambin para simplificar la funcin mediante tramos definidos como
polinomios.
El caso ms sencillo de spline es el polinomio de primer orden, es decir, rectas que unan los
puntos. ste genera curvas con puntas donde la pendiente no est definida en los puntos.
Cuanto mayor es el orden del polinomio de la aproximacin, aparecen ms oscilaciones,
generando curvas de peor calidad.
Figura 2.1. Aproximacin de primer orden (recta)

y aproximacin de un orden muy superior.
Se suelen usar polinomios de ordenes bajos, normalmente suelen ser de segundo o tercer
orden. En general se busca una curva que pase por los puntos definidos y que lo haga con la
misma pendiente que la funcin en los puntos. Esto se consigue con polinomios de tercer
orden.
Si lo nico que se tiene es la distribucin de puntos de la funcin se debe hacer una estimacin
de la pendiente utilizando puntos de alrededor. Si la separacin entre los puntos es uniforme
la pendiente de un punto se puede igualar a la pendiente de la recta entre los dos puntos
adyacentes.
Figura 2.2. Aproximacin de la pendiente mediante dos puntos adyacentes.
- 17 -
Mtodos numricos
Siendo la pendiente:
|
Donde el error es (
los puntos.
(2.1)
) y decrece de forma cuadrtica con la disminucin del intervalo entre
En el caso de estar en los puntos extremos, al faltar uno de los puntos, se aproxima la
pendiente con el propio punto. Por ejemplo si se est en el ltimo punto no se tendra un
punto a la derecha y por lo tanto la pendiente sera:
( )
(2.2)
Se puede ver que el error ( ) ha aumentado considerablemente con esta aproximacin.
2.2.
Interpolacin cbica en un solo intervalo
Para encontrar la funcin interpolada de tercer orden en un intervalo, se hace primero un

[
] se transforma a una variable definida en
cambio de variable. Teniendo una variable
[ ]. El cambio de variable es simplemente:
un intervalo unitario
(2.3)
Se usan polinomios de Hermite para encontrar la funcin interpolada. Se tienen cuatro
funciones bsicas de Hermite, siendo la funcin interpolada una combinacin lineal de estas
cuatro funciones.
Las funciones solo pueden empezar en
solo pueden ser o .
y deben acabar en
o . Las en
Figura 2.3. Las cuatro funciones bsicas de Hermite.

Se busca un polinomio que pase por dos puntos conocidos (
tambin coincida ( y ).
- 18 -
) y que adems la pendiente
Mtodos numricos
El polinomio es por lo tanto:

( )
( )
( )
4(
(2.4)
El valor de las funciones bsicas de Hermite se pueden calcular fcilmente ya que son
polinomios de tercer orden. Se calcula como ejemplo la cuarta funcin 4 . Esta funcin tiene
doble raz en
(ya que la pendiente en ese punto es ) y la tercera raz en
. A parte
se sabe que la pendiente en
es . Por lo tanto la funcin tiene la siguiente forma, donde
es una constante que se debe calcular.
(
Como la pendiente en
(2.5)
es , se puede obtener el valor de la constante.

4
)|
(2.6)
Por lo tanto el cuarto polinomio es:

(
(2.7)
Las dems funciones se obtienen de forma similar y son:

(
)(
(2.8)
Para el valor de la pendiente tambin se tiene que hacer el cambio de variable.

(2.9)
Sabiendo del cambio de variable que:
(2.10)
Por lo tanto:
(
(2.11)
Finalmente la funcin interpolada es:

(
)(
(
(
)
)
- 19 -
(
(
)
)
(2.12)
2.3.
Mtodos numricos
Programa
Programa 3. Entrada de datos e interpolacin

En este programa se ve un ejemplo de programa que puede leer y escribir en un archivo.
Adems se utiliza en el programa una subrutina para hacer la interpolacin.
El programa debe de ser capaz de leer un archivo con una serie de puntos de una funcin.
Pregunta cuantos puntos se quieren tener de salida y genera unos puntos utilizando la
interpolacin cbica. Los nuevos puntos calculados se escriben en un fichero de salida para
poder comparar la funcin de entrada y la de salida.
Se empieza escribiendo la subrutina. Se debe empezar definiendo las variables que se van a
usar. Esta subrutina calcula un valor de ( ) (yx) para una posicin de (x). Para calcular la
funcin interpolada se necesitan los valores de la funcin en los extremos del tramo ( y ) y
las pendientes en esos puntos ( y ), se utiliza un vector de cuatro posiciones para guardar
estos valores (v1(4)). Adems se necesita saber el valor del tramo y , se guardan tambin
en un vector (v2(2)).
subroutine hermite (v1, v2, x, yx)
implicit none
real, intent(in) :: v1(4), v2(2), x
real, intent(out) :: yx
Se tiene que hacer el cambio de variable de
a definido por la ecuacin (2.3).
real :: chi, span

span =v2(2) - v2(1)
chi = (x - v2(1)) / span
Se calcula ahora el valor ( ) con la formula de la interpolacin descrita en la ecuacin (2.12).
Se puede utilizar el carcter & al final de una lnea para indicar que el cdigo sigue como si no
hubiese un salto de lnea, esto facilita la lectura del cdigo y no afecta al programa.
yx = v1(1) * (1. + 2. * chi) * (1. - chi) * (1. - chi) + &
v1(2) * span * chi * (1. - chi) * (1. - chi) + &
v1(3) * chi * chi * (3. - 2. * chi) + &
v1(4) * span * chi * chi * (chi - 1.)
end subroutine
Se debe hacer ahora el programa principal que es el que lea los datos de entrada calcule los
nuevos valores y los escriba en un fichero.
- 20 -
Mtodos numricos
Lo primero que se debe hacer es definir las variables. Se usan vectores y matrices para guardar
los datos de entrada. Se define una matriz para guardar el valor de la funcin y el valor de su
derivada, y un vector para almacenar la posicin en el eje . Como el programa no sabe an
cuantos valores de la funcin se tienen (los debe leer del archivo) se deben definir estas
matrices como allocatable.
Como variables adicionales se definen el nmero de valores de entrada (n) y el nmero de
valores de salida (nExit). Adems de estas variables se definen otras que ayudarn a la hora de
programar.
program program3
implicit none
real, allocatable :: ydy(:,:), x(:)
real xInt, yInt, step
integer n, i, nExit, last
Se debe leer el archive con los datos para saber la dimensin de las matrices. Se pone como
primer dato el nmero de valores de la funcin, y luego, en cada lnea los valores de la funcin.
Se utiliza la funcin allocate para dar las dimensiones a las matrices.
open(unit = 1, file='initialData', access='SEQUENTIAL')
read(1,*) n
allocate(ydy(2,n), x(n))
do i = 1, n
read(1,*) x(i), ydy(1,i)
end do
close(1)
Como solo se tiene la informacin de los puntos y de la funcin en los puntos se debe
aproximar la derivada. Se utiliza la ecuacin (2.2) para los puntos externos y la ecuacin (3.1)
para el resto.
Una vez calculadas las derivadas se pide el nmero de puntos de salida.
ydy(2,1) = (ydy(1,2) - ydy(1,1)) / (x(2) - x(1))
do i = 2, n - 1
ydy(2,i) = (ydy(1, i+1) - ydy (1, i-1)) / (x(i+1) - x(i-1))
end do
ydy(2,n) = (ydy(1,n) - ydy(1,n-1)) / (x(n) - x(n-1))
print *, 'Introduce number of points:'
read(*,*) nExit
- 21 -
Mtodos numricos
Se iguala la variable xInt a x(1). La variable xInt es la posicin

Calcula tambin el paso entre los puntos interpolados.
de la funcin interpolada. Se
(2.13)
Como se va a empezar a escribir resultados se abre el archivo de resultados. El parmetro que
se le ha puesto en status genera un nuevo documento cada vez que se ejecuta el programa.
En caso de que el documento ya exista, borra el anterior y crea uno nuevo.
xInt = x(1)
step = (x(n) - x(1)) / real(nExit - 1)
open(unit=2, file='dataExit', access='SEQUENTIAL', status='REPLACE')
Se empieza ahora el bucle de clculo. Cada vez que se hace una iteracin se calcular los puntos
que forman el intervalo en el que xInt est.
last = 1
do i = 1, nExit
!Find interval
do while (xInt .gt. x(last+1))
last = last + 1
end do
Se llama a la subrutina para obtener el valor de yInt para el punto xInt. Una vez se obtiene el
valor, se escribe el resultado en el archivo. Finalmente antes de terminar el bucle se toma un
nuevo valor de xInt y se asegura que todos los valores iniciales de se han tomado.
call hermite(ydy(:,last:last+1), x(last:last+1), xInt, yInt)
write(2,*) xInt, yInt
xInt = xInt + step
xInt = min(xInt, x(n))
end do
close(2)
end program
Debido a que Fortran nicamente enva del vector la direccin de memoria del primer valor
asignado, se puede escribir la llamada de la subrutina de la siguiente manera.
call hermite(ydy(1,last), x(last), xInt, yInt)
- 22 -
Mtodos numricos
3. Integracin
3.1.
Frmula de Newton-Cotes
Si se tiene una funcin ( ) con
], la integral se define segn:
Sean los elementos de rea por debajo de la funcin donde

Si es suficientemente grande tal que |
y la particin de los elementos es
|
regular, la integral entre y de ( ) es igual a un sumatorio de los elementos.
( )
) ( )
Si la funcin est definida en un rango de valores de

los valores de ( ).
(3.1)
, podra haber problemas para obtener
Una primera forma de calcular la integral es a travs de la formula de Newton Cotes. Se puede
muestrear la funcin en una serie de puntos y extrapolar los puntos a funciones que se puedan
integrar como polinomios. Finalmente se hace la integral de los polinomios.
Como convenio, cuando se escogen los puntos de los intervalos para integrar, se escogen los
dos extremos y el resto se suelen coger de forma que el intervalo entre puntos es regular
(siendo muy cmodo que el intervalo sea igual).
Se considera una funcin como la que se ve en la Figura 3.1.
()
Figura 3.1. Funcin aleatoria dividida en
intervalos.
Si los intervalos son iguales ste se puede calcular fcilmente con la posicin de los extremos.
(3.2)
Teniendo el valor de ( ) para todos los puntos (
) se calculan las funciones
(
)
polinmicas que aproximan a
para cada intervalo. Esta aproximacin polinmica puede
- 23 -
Mtodos numricos
ser del orden que se desee, pudiendo aproximar con rectas, parbola u otros.La integral es
entonces la integral de los polinomios (el conjunto se define como ).
( )
( )
(3.3)
El polinomio se calcula mediante la interpolacin polinmica de Lagrange. Para un intervalo

que empieza en , el polinomio interpolado en la forma de Lagrange es la siguiente
combinacin lineal.
( )
Donde
(3.4)
es la delta de Kronecker.
{
(3.5)
Por lo tanto el polinomio interpolado queda:

( )
)(
)(
) (
) (
)(
)(
+
+
(
) (
)
)
(3.6)
Si es muy grande, el polinomio tiene muchas oscilaciones y puede variar mucho respecto a la
funcin inicial. Los valores tpicos de son
y . Al tener un pequeo, el polinomio de
Lagrange queda muy simplificado.
El error es la diferencia entre la integral que se quiere obtener y el valor obtenido.
( )
(3.7)
En general el error al interpolar una funcin en un polinomio de orden

Por lo tanto el error al integral es del orden de:
+
es del orden de
(3.8)
Este error se denomina error simple ya que es el error de un solo intervalo. El error producido
por todos los intervalos se denomina el error compuesto.
+
Como adems se sabe que
( )
(3.9)
+( )
(3.10)
) , el error compuesto es por lo tanto del orden de:

(
- 24 -
(3.11)
3.2.
Mtodos numricos
Regla del punto medio
La regla del punto medio establece que la funcin en los intervalos es constante, tomando solo
un punto del intervalo. Los intervalos se normalizan para que quede una funcin comprendida
entre
y .
()
()
Figura 3.2. Normalizacin de la funcin.

Siendo:
( )
( )
(3.12)
Se aproxima ( ) a una recta cuyo valor es ( ). La integral de esta funcin es por lo tanto:
( )
( )
( )
(3.13)
Pese a que este caso sera el caso en que

el error simple no es . Segn el teorema de
Taylor, una funcin se puede aproximar como un polinomio de la siguiente forma:
( )
( )
( )
(3.14)
( )). Pero el segundo

La aproximacin que se usa en este caso es de orden ( ( )
trmino (que en teora tendra que definir el error) es cero al integrarse, ya que es una funcin
antisimtrica entre y
. Por lo tanto el error viene definido por el tercer trmino y es:
(3.15)
3.3.
Regla del trapecio
Se aumenta el orden y ahora se toman dos puntos del intervalo en vez de uno. El polinomio
que aproxima el intervalo es por lo tanto una recta que pasa por los dos lmites del intervalo.
Se vuelve a normalizar la funcin para que est contenida entre
y .
()
()
Figura 3.3. Polinomio normalizado produciendo un trapecio en el intervalo.
- 25 -
Mtodos numricos
La integral del polinomio es igual al rea del trapecio.

(
( )
( )
(3.16)
La integral completa es la suma de las integrales de los distintos intervalos.

( )
( )
( )
( )
(3.17)
Agrupando trminos iguales se puede simplificar la expresin.

( )
( )
(3.18)
Se define el primer trmino de la ecuacin anterior como .

( )
( )
( )
(3.19)
Al estar aproximando de forma lineal el error simple es un trmino de segundo orden que al
integrar se convierte en tercer orden. El error compuesto es de segundo orden. Los errores son
del mismo orden de magnitud que los de la regla del punto medio, pero no son iguales.
(3.20)
En general no basta con calcular una vez la integral para obtener un resultado vlido. Se deben
probar distintos valores de intervalos para comprobar si el resultado converge. Para no tener
que calcular desde el principio cada vez. Es recomendable aprovechar los resultados obtenidos
en las anteriores integraciones y una forma de hacerlo es dividir por dos el valor del
intervalo , es decir poner un punto ms en el centro de cada intervalo. De esta forma solo se
tienen que calcular la mitad de puntos.
Si se hace con este mtodo se empezara calculando la integral con un intervalo
resultado saldra de hacer el siguiente clculo:
. El
( ))
(3.21)
Nunca se debe dar por vlido el resultado de la primera integracin y por lo tanto hay que
y por lo tanto
hacer una segunda. Se tiene
, y adems se define
el
resultado del sumatorio de la primera integracin.
( ))
))
(3.22)
Se ve fcilmente que solo es necesario hacer la mitad de los clculos al solo tener que calcular
los intervalos con subndice impar. De forma similar se pueden ir haciendo iteracin y el
trabajo de cada iteracin es el mismo.
- 26 -
3.4.
Mtodos numricos
Regla de Simpson
En la regla de Simpson se extrapolan los intervalos en parbolas. Se toman tres puntos de cada
intervalo (
), los puntos son los extremos y el punto central del intervalo. De forma similar
].
se centra a los estudios anteriores, se centra el intervalo en [
()
()
Figura 3.4. Extrapolacin parablica utilizando tres puntos.

Para obtener el valor de la integral por del intervalo se puede usar el polinomio interpolante
de la ecuacin (3.6), como se ha dicho antes el orden es
.
(
)(
)(
( )
)
( )
Se integra el polinomio entre
(
(
)(
)(
)
)
( )
(
(
( )
)(
)(
)
)
(3.23)
y .
(
( )
( )
(3.24)
Para calcular la integral completa se deben sumar las integrales de todos los intervalos. En este
caso se toman grupos de tres puntos, y por el nmero de puntos (Figura 3.5) debe ser un
nmero par.
()
Figura 3.5. Lmites de los intervalos de integracin.
- 27 -
Mtodos numricos
La integral completa es por lo tanto (siendo como antes

[
( )
( )
( )]
) ):
)]
(3.25)
Si se agrupan los trminos similares se obtiene:

[
( )
( )
( )
(
( )
))
)]
(3.26)
El clculo del error es similar al de la regla del punto medio. Como es una regla cuadrtica se
4
podra pensar que el error seria
que viene de integrar . Pero
es una funcin
antisimtrica y al integrarla entre
el error compuesto es
3.5.
da cero. El error simple es por lo tanto
Extrapolacin de Richardson
Se puede acelerar el clculo numrico (aumentando por lo tanto el orden de convergencia)

con mtodos como la extrapolacin de Richardson. Permite a partir de un orden de
convergencia , tener una aproximacin
. Es preferible que sea .
Supongase que ( ) es una estimacin de orden
para:
( )
(3.27)
Al no poder hacer el lmite infinito, se hace una aproximacin de
utilizando ( ).
( )
Donde
(3.28)
son constantes desconocidas reales y

.
son constantes conocidas tal que
Si solo se toma el primer trmino, la aproximacin queda:

( )
(3.29)
como funcin de .
Dividiendo el paso por dos se escribe
( )
( )
(3.30)
Utilizando las ecuaciones (3.29) y (3.30) se elimina la constante desconocida

(
( )
)
( )
( )
( )
- 28 -
.
(3.31)
(3.32)
Mtodos numricos
Con este proceso, se obtiene una mejor aproximacin de eliminando el mayor trmino de
error que es ( ). Este proceso se puede repetir para eliminar trminos de error para
obtener una mejor aproximacin.
El problema es que no se suele saber el valor de . Se suele usar igual al orden de cuadratura
del mtodo usado o hacer una aproximacin del valor haciendo algunas iteraciones.
Se calcula la aproximacin de
para el intervalo .
( )
Se elimina la constante desconocida

(
( )
(3.33)
utilizando la ecuacin (3.30).

)
( )
( )
(3.34)
Si est a punto de converger se podra decir que el hecho de dividir el intervalo por la mitad no
afecta al resultado.
( )
( )
( )
( )
(3.35)
Pudiendo aislar :
( ( )
( ))
( )
( )
- 29 -
( )
( )
( )
)
( )
(3.36)
3.6.
Mtodos numricos
Programas
Programa 4. Obtencin de la serie de Fourier

En este programa se quiere calcular los coeficientes de una serie de Fourier. Los coeficientes
de la serie de cosenos se obtienen utilizando la frmula integral.
( )
( )
(3.37)
De forma similar se pueden obtener los coeficientes de la serie de senos.
( )
(3.38)
Una vez se tienen los coeficientes de la serie de cosenos y los coeficientes de la serie de senos
se pueden calcular la amplitud y el desfase.
(3.39)
Las integrales se hacen utilizando el mtodo del trapecio. Se crea una subrutina que calcule la
integral de una funcin. A esta subrutina se le debe dar un vector y(n) donde se almacenen los
valores de la funcin.
subroutine trapice(y, b, z, n)
implicit none
integer, intent (in) :: n
real, intent (in) :: y(n), b
real, intent (out) :: z
z = 0.5 * (y(1) + y(n))+ sum(y(2:n-1))
z = z * b / (real(n) - 1.)
end subroutine
La subrutina fourier debe calcular las fases y las amplitudes. Debe ir llamando a la subrutina
trapice para calcular los coeficientes de la serie de cosenos y senos.
Los valores de las amplitudes y de las fases se almacenan en una matriz llamada
modes(2,0:m). Se le asigna un rango definido a la matriz (0:m) para mantener el convenio de
subndices.
La variable n es el nmero de puntos seleccionados de la funcin para hacer las integrales. La
variable m es el nmero de trminos de la serie de Fourier que se quieren calcular.
Se aaden adems una serie de parmetros como pi o su inversa invPi. Como se sabe que se
va a dividir por bastantes veces es recomendable tener una variable que guarde su inversa y
as solo tener que hacer multiplicaciones.
- 30 -
Mtodos numricos
subroutine fourier (y, modes, n, m)

implicit none
integer, intent (in) :: n, m
real, intent (in) :: y(n)
real, intent (out) :: modes(2, 0:m)
integer i
real z(n), x(n), dx, invPi, a, b
real, parameter :: pi = acos(-1.)
invPi = 1. / pi
Se inicializa el vector de los puntos .

dx = 2. * pi / (real(n) - 1.)
x(1) = -pi
do i = 2, n
x(i) = x(i-1) + dx
end do
Se calculan ahora los coeficientes de las series y luego finalmente las amplitudes y fases. El
primer coeficiente
se calcula fuera del bucle, este valor es ya la amplitud y no hay fase
porque no multiplica una funcin trigonomtrica.
!First coeficient
call trapice(y, 2.*pi, a, n)
modes(1,0) = a * 0.5 * invPi
do i = 1, m
!Cos coeficients
z = y * cos(real(i) * x)
call trapice(z, 2.*pi, a, n)
a = a * invPi
!Sin coeficients
z = y * sin(real(i) * x)
call trapice(z, 2.*pi, b, n)
b = b * invPi
!Amplitudes and phases
modes(1,i) = sqrt(a*a + b*b)
modes(2,i) = -atan(b / a)
end do
end subroutine
- 31 -
Mtodos numricos
Finalmente se escribe la funcion principal del programa. Se utiliza una funcin de ejemplo que
ya est escrita con sus amplitudes y fases para poder comprobar si el programa funciona bien.
La funcin escogida es:
.
(3.40)
El programa debe primero seleccionar una serie de puntos y calcular el valor de la funcin
almacenndolos en el vector y(n). El programa llama a la subrutina fourier que es la que se
encarga de devolver las amplitudes y fases.
program program4
implicit none
integer, parameter :: n = 300
integer i
real y(n), step, x, modes(2, 0:8)
x = -pi
step = 2. * pi / (real(n) - 1.)
!Discretization
do i = 1,n
y(i) = 0.5 + 3. * cos(2. * x + 0.75) + 1. * cos(6. * x + 0.25)
x = x + step
end do
call fourier (y, modes, n, 8)
!Print results
do i = 0, 8
print* , modes(1,i), modes(2,i)
end do
end program
- 32 -
Mtodos numricos
Programa 5. Iteraciones y extrapolacin

En este programa se calcula la integral de una funcin mediante el mtodo del trapecio pero
disminuyendo en cada iteracin el tamao del intervalo entre dos puntos.
Como ya se ha explicado en el tema 3.3, si se divide el intervalo en dos, en los puntos donde ya
se ha evaluado la funcin no hace falta volver a calcularlos y por lo tanto solo hay que hacer la
mitad de clculos para cada iteracin.
Para este programa se utilizan variables con double precision. Para ello las funciones
trigonomtricas que se deben usar son dsin y dcos. En ambas se debe introducir una variable
de double precision. Para transformar el tipo de variable se usa la funcin dble.
Se crea una subrutina que calcula la funcin. La funcin de ejemplo es:
(
(3.41)
subroutine evaluateFunction(x, y)
implicit none
real* 8, intent(in) :: x
real* 8, intent(out) :: y
y = dcos(5. * x) + 3. * x * x
end subroutine
El programa principal se encarga de ir evaluando la funcin y sumando esos valores a la

variable suma. Con sta se puede calcular la integral en funcin del valor del intervalo de la
iteracin.
Se inicializan los valores de las distintas variables y se evala la suma de los puntos extremos,
que si adems se divide por dos se obtiene el coeficiente de la ecuacin (3.19). El nmero de
intervalos viene definido por la variable n.
program program5
implicit none
integer :: i, j, n
real*8, parameter :: a = 0., b = 1.
real*8 suma, prevInteg, integ, h, sumEnds, aux, x
n = 10
h = (b - a) / dble(n)
suma = 0.
!Sum of limits divided by two
call evaluateFunction(a, aux)
sumEnds = aux
call evaluateFunction(b, aux)
sumEnds = (sumEnds + aux) * 0.5
- 33 -
Mtodos numricos
Lo siguiente es hacer el bucle iterativo. En cada iteracin simplemente hay que sumar los
valores de la funcin a la variable suma. Se debe diferenciar la primera iteracin de las dems
ya que en la primera hay que evaluar la funcin en todos los puntos y en las dems
simplemente hay que evaluarla cuando j (subndice del punto ) sea impar.
do i = 1, 10
!Sum of the values of the function
if(i .eq. 1) then
x=a+h
do j = 1, (n - 1)
call evaluateFunction (x, aux)
suma = suma + aux
x=x+h
end do
else
x=a+h
do j = 1, (n - 1), 2
suma = suma + aux
x=x+2*h
end do
end if
La integral se obtiene multiplicando la suma de todos los puntos (dividiendo por dos los
lmites) y multiplicndolo por el intervalo, ecuacin (3.18). Una vez obtenido el valor de la
integral se calcula el tamao del intervalo y el nmero de intervalos para la prxima iteracin.
!Integral
integ = h * (sumEnds + suma)
!Number of intervals and size of interval
n=2*n
h = 0.5 * h
Se sabe que el resultado analtico de la integral es:

(
(3.42)
El resultado que se imprime es la comparacin del resultado calculado y el resultado analtico.

!Results
print*, integ - (.2 * dsin(dble(5.)) + 1.)
end program
- 34 -
Mtodos numricos
El programa ya est acabado. Si se ejecuta se puede ver como el error va disminuyendo a

medida que se van haciendo iteraciones. Si se aumenta el nmero de iteraciones (en este
programa se tiene que cambiar el ltimo valor del bucle do) se puede ver que llega un punto
en el que el error vuelve a aumentar. Esto es debido a los errores de redondeo. En este
programa se necesita aumentar mucho el nmero de iteraciones porque se han utilizado
variables de mucha precisin justamente para evitar este problema.
Se puede extrapolar el resultado de la integral utilizando el mtodo e extrapolacin de
Richardson. El valor de la integral extrapolada se calcula utilizando la ecuacin (3.32). Como se
usa el mtodo del trapecio, el orden de convergencia es .
( )
( )
( )
( )
(3.43)
El resultado de cada iteracin se puede mostrar junto al resultado utilizando la extrapolacin

de Richardson.
!Richardson extrapolation
if(i .eq. 1) then
print*,"No extrapolation", " With extrapolation"
analitical = .2 * dsin(dble(5.)) - 1.
else
aux = (4. * integ - prevInteg) / 3.
print*, integ - analitical, aux - analitical
end if
prevInteg = integ
end do
end program
- 35 -
Mtodos numricos
4. Resolucin numrica de ecuaciones no lineales

4.1.
Mtodo de la biseccin
Los mtodos de resolucin numrica de ecuaciones no lineales permiten la obtencin de

resultados de para una funcin tal que ( )
. A la solucin se le llama raz o cero de la
funcin.
El primer mtodo se basa en el teorema de Bolzano. Sea una funcin real continua en un
] con ( ) y ( ) de signos contrarios. Entonces existe al menos un
intervalo cerrado [
), con ( )
punto del intervalo abierto (
.
El teorema como tal no especifica el nmero de puntos, pero afirma que al menos existe uno.
] tal
(
) ) de un intervalo [
El mtodo consiste en ir tomando el punto medio (
que ( ) y ( ) de signos contrarios. Se forman dos tramos y se escoge el tramo tal que la
funcin en los lmites sea de signo contrario. Si por ejemplo ( )
y ( )
se tienen
dos opciones:
( )
( )
(4.1)
El proceso se repite en cada iteracin. La solucin es:

(4.2)
Si no hubiese errores de redondeo al hacer infinitas iteraciones se obtendra el resultado.
(4.3)
La velocidad con la cual la sucesin de iteraciones converge se llama orden de convergencia. Si

se tiene una secuencia que converge a un valor , se dice que la sucesin converge con
orden a .
|
|
El nmero es llamado orden de convergencia, y en el caso del mtodo de Bolzano

por lo tanto un mtodo muy lento.
(4.4)
. Es
En general no se puede calcular el orden de convergencia exacto, pero utilizando unas cuantas
iteraciones se puede estimar, aunque siempre considerando que a funcin converge.
4.2.
Mtodo de Newton - Raphson
El mtodo de Newton - Raphson es un mtodo con un orden de convergencia mucho mayor,

en general su orden de convergencia es .
- 36 -
Mtodos numricos
Para ste mtodo se debe escoger un punto que se aproxime a la solucin. La cercana del
punto a la solucin es importante para que el resultado converja. Se puede aproximar la
funcin en una recta en ese punto utilizando la serie de Taylor.
( )
Se busca el punto
( )
( ) (
en el cual ( )
(4.5)
.
( )
( ) (
( )
( )
(4.6)
(4.7)
( )
( )
Figura 4.1. Primera iteracin del mtodo de Newton-Raphson.

Se obtiene una regla de recurrencia y por lo tanto se pueden ir haciendo iteraciones hasta
obtener el resultado deseado. Adems es una regla cuadrtica (
). Pero tiene algunos
problemas:
4.3.
Contiene la derivada de la funcin, y en ocasiones no es posible obtenerla si por

ejemplo no se tiene una expresin analtica de la funcin.
Es un mtodo abierto, la convergencia no est garantizada por un teorema de
convergencia global. El resultado depende del primer valor que se estima. Se pueden
por ejemplo tener problemas con mximos y mnimos.
Mtodo de la secante
Con este mtodo se evita el primer problema que tiene el mtodo de Newton-Raphson. Se
aproxima la tangente mediante la secante que pasa por dos puntos. En este mtodo se
necesitan dos puntos iniciales. La aproximacin de la derivada es:
( )
( )
( )
(4.8)
Y por lo tanto:
( )
- 37 -
( )
( )
(4.9)
Mtodos numricos
( )
( )
( )
Figura 4.2. Dos primeras iteraciones del mtodo de la secante.
En este caso se gana en simplicidad y flexibilidad de ejecucin pero se pierde en orden de
convergencia. Este mtodo no es cuadrtico pero su orden de convergencia suele ser entre .
y . , y por lo tanto no es tan rpido como el mtodo de Newton-Raphson.
Este mtodo tiene el mismo problema que el mtodo de Newton-Raphson por lo que no se
puede asegurar la convergencia y sta depende de los valores iniciales.
4.4.
Mtodo de regula falsi
El mtodo de regula falsi o falsa posicin es una combinacin del mtodo de la secante y el
mtodo de la biseccin. El orden de convergencia ronda la unidad (convergiendo ms
lentamente que el mtodo de la secante) pero ste mtodo asegura la convergencia a
diferencia de por ejemplo el mtodo de la secante.
Se debe empezar con dos valores iniciales tal que los signos de la funcin es esos puntos son
opuestos, garantizando que hay al menos una raz en el interior del intervalo (teorema de
Bolzano). Se traza una recta entre los dos puntos y se calcula el cero de esta recta.
( )
( )
( )
Figura 4.3. Dos primeras iteraciones del mtodo regula falsi.
- 38 -

Se calcula el punto
Mtodos numricos
a partir de los puntos
( )
( )
( )
( )
(4.10)
Una vez se obtiene el nuevo punto se calcula ( ) y se elige un nuevo intervalo que cumpla
que la raz est dentro de l. En el caso del ejemplo de la Figura 4.3 se toman los nmeros y
, ya que ( ) ( )
. Se repite el proceso de forma iterativa.
ste mtodo puede resultar lento si por ejemplo se tiene una funcin como el de la Figura 4.4
y adems no se puede asegurar que el resultado haya convergido correctamente (no se puede
asegurar que el error sea mayor de lo estimado). Esto es debido a que en esta funcin las
iteraciones avanzan solo en una direccin.
( )
( )
( )
Figura 4.4. Dos primeras iteraciones.
4.5.
Teorema del punto fijo
El ltimo mtodo de estudio consiste en obtener una ecuacin del tipo

( ).
de forma iterativa utilizando un valor inicial +
( ). Se resuelve
Grficamente este mtodo consiste en encontrar el punto donde se cruza una funcin
( ). Para ello se empieza con un valor , se calcula el valor de ( ) y se
y otra funcin
busca del valor de que sea igual.
( )
( )
Figura 4.5. Dos primeras iteraciones, convergiendo.
- 39 -
Mtodos numricos
Este mtodo puede no converger. Para que converja se debe cumplir que en la solucin
| ( )|
. Si no se cumple la condicin, la solucin diverge alejndose en cada iteracin de
la solucin, como se puede ver en la Figura 4.6.
Figura 4.6. Tres primeras iteraciones, divergiendo.
- 40 -
4.6.
Mtodos numricos
Programas
Programa 6. Deflexin de un cable

En muchas pelculas de superagentes como por ejemplo James Bond se suelen ver como
atraviesan una calle entre edificios solamente con un cable. Considerando que realmente
pueden clavar el cable en el edificio de en frente y que se mantiene sujeto, se quiere estudiar
si realmente el cable se mantiene rgido como muestran normalmente.
Se tiene una cable sujeto en los extremos entre dos paredes y aguantando un peso en el
centro, como muestra la Figura 4.7. El cable est caracterizado por sus propiedades y . En
general las cuerdas que se usan para estos casos se llaman cuerdas de piano y son bastante
rgidas. Est claro que en ningn caso estas cuerdas se pueden enrollar en un reloj o en el
cinturn.
Figura 4.7. Diagrama del cable con un peso en el medio.

La tensin se relaciona con el peso del superagente utilizando el equilibrio de fuerzas
verticales, siendo el ngulo que forma el cable deflectado con la horizontal.
(4.11)
Suponiendo que la deformacin es lineal la tensin del cable
deformacin .
genera una pequea
(4.12)
La longitud del cable estirado se puede relacionar con la longitud inicial del cable .
(4.13)
Por lo tanto la deformacin es:
(4.14)
Se juntan las ecuaciones (4.11), (4.12) y (4.14) se obtiene una relacin entre el peso del
superagente y el ngulo .
(
- 41 -
(4.15)
Mtodos numricos
Simplificando la ecuacin un poco se obtiene la ecuacin que se quiere resolver

numricamente. En muchos problemas de fsica es bueno adimensionalizar las ecuaciones ya
que estas muestran en un parmetro la relacin entre propiedades importantes del problema.
En este caso se relaciona el peso del superagente con la rigidez del cable.
(4.16)
Se debe hacer una aproximacin del resultado para tener un valor inicial. Se puede considerar
que el ngulo es pequeo | |
. Esto no implica que
y
ya que la
ecuacin
no tiene sentido. El problema est en el coseno de la ecuacin (4.15). Se
aproxima con un orden superior:
(4.17)
Adems se puede incluso hacer otra aproximacin para facilitar la resolucin de la ecuacin.
(4.18)
Por lo tanto la solucin aproximada es:
(4.19)
Se utiliza el mtodo de la secante para resolver la ecuacin. Se puede aproximar el resultado

utilizando un nmero cercano de la aproximacin obtenida, por ejemplo
.
.
Se toman los siguientes valores de las propiedades del cable y del superagente:
(4.20)
Lo primero que hay que hacer en este programa es calcular los valores iniciales. Adems se
crea una variable

.
.
program Program6
implicit none
integer i, j, n
integer, parameter :: itMax = 7
real, parameter :: k = 0.25E-3
real x1, x2, x3, fx1, fx2, slope
x1 = (2. * k)**(1./3.)
x2 = 1.1 * x1
Se empieza ahora el bucle iterativo. En este se debe evaluar la funcin en el ltimo valor
calculado de (para el cdigo es x2). Como el primer valor (el primer x1) solo se tiene que
calcular una vez ste se calcula justo antes de iniciar el bucle.
- 42 -
Mtodos numricos
Como proteccin se pone una salida del bucle en caso de que x1 sea igual a x2. Este caso
significara que ya se tiene la solucin y se evita adems hacer clculos con divisiones por cero.
fx1 = k + sin(x1) - tan(x1)
print*, 'x= ', x1, 'f(x) = ', fx1
do i = 1, itMax
if (x1.eq.x2) exit
fx2 = k + sin(x2) - tan (x2)
print*, 'x = ', x2, 'f(x) = ',fx2
Para hacer la nueva iteracin se calcula la pendiente utilizando los dos resultados anteriores y
se usa la ecuacin (4.9) para calcular el nuevo valor x3. Una vez calculado se vuelven a
establecer las variables x1 y x2.
slope = (fx2 - fx1) / (x2 - x1)
x3 = x2 - fx2 / slope
x1 = x2
x2 = x3
fx1 = fx2
end do
end program
- 43 -
Mtodos numricos
Programa 7. Resolucin mediante Newton-Raphson

Se resuelve la misma ecuacin mediante el mtodo de Newton-Raphson. En este caso no se
necesitan tener dos valores iniciales pero s que se necesita la derivada de la funcin.
( )
(4.21)
Como se utilizan varias veces las funciones trigonomtricas se puede optimizar el programa
creando dos variables cosx y sinx que calculen solo una vez por iteracin la funcin
trigonomtrica.
program Program7
implicit none
integer i, j, n
real x1, x2, fx1, slope, cosx, sinx
x1 = (2. * k)**(1./3.)
do i = 1, itMax
cosx = cos(x1)
sinx = sin(x1)
fx1 = k + sinx - sinx / cosx
slope = cosx - 1. / (cosx * cosx)
print*, 'x = ', x1, 'f(x) = ', fx1
if (fx1 .eq. 0) exit
x1 = x2
end do
end program
- 44 -
Mtodos numricos
5. Resolucin numrica de sistemas lineales

5.1.
Mtodo de eliminacin de Gauss
El mtodo de eliminacin de Gauss es un algoritmo de lgebra lineal para determinar

soluciones de un sistema de ecuaciones lineales.
Se obtienen las soluciones del sistema lineal mediante la reduccin del sistema dado a otro
equivalente en el que cada ecuacin tiene una incgnita menos que la anterior.
Se transforma la matriz del sistema de ecuaciones en una matriz triangular superior.
Obteniendo la solucin de la ltima incgnita y pudiendo ir hacia atrs resolviendo las dems
incgnitas del sistema.
(5.1)
(
){
A un sistema de ecuaciones lineal se le pueden hacer una serie de operaciones llamadas

elementales.
a. Multiplicar una ecuacin por un escalar no nulo.
b. Intercambiar de posicin dos ecuaciones.
c. Sumar a una ecuacin un mltiplo de otra.
En el caso del sistema matricial, ests se traducen en:
a. Multiplicar una fila de la matriz y la fila del vector solucin ( ) por un escalar.
b. Intercambiar dos columnas de la matriz y dos filas del vector incgnitas.
c. Sumar los trminos de una fila a otra de la matriz y del vector solucin.
Para poder obtener la matriz triangular se debe, para cada fila:
Se debe ir a la columna que empiece a partir de la diagonal .

Si ste valor es nulo se debe cambiar la columna por otra que est a la derecha y que
tenga un valor no nulo. Si coincide que se est en la ltima fila con todos los valores
nulos, el sistema es indeterminado.
Se deben obtener ceros por debajo de
sumando mltiplos adecuados de la fila
superior a las filas de debajo.
Una vez obtenida la matriz triangular se pueden ir obteniendo los calores de las resultados
partiendo del ltimo.
El buen resultado de este mtodo depende de la calidad de la matriz, que est relacionado con
el radio espectral de la matriz, definido por el supremo de entre los valores absolutos de los
elementos de su espectro.
- 45 -
5.2.
Mtodos numricos
Matrices mal condicionadas
Existen varias formas de definir una matriz mal condicionada. Una matriz de un sistema de
ecuaciones lineales (
) est mal condicionada si, por ejemplo, pequeos errores o
variaciones en los elementos de o tienen un gran efecto en la solucin exacta de .
Otra forma de definirlo de forma sencilla es que una matriz est mal condiciona si el
determinante es anormalmente pequeo. Se puede comparar con la norma de la matriz ,
estando mal condicionada si | | . La norma de la matriz (RMS) se puede calcular como:

(5.2)
Como ejemplo se define el siguiente sistema de ecuaciones siguiente, donde
(5.3)
(
)
No se puede despreciar ya que si se hiciese el sistema no tendra solucin (el determinante
es nulo). Se utiliza el mtodo de eliminacin de Gauss.
{
(5.4)
La solucin del sistema es por lo tanto:

(
(5.5)
Se puede ver que tanto la solucin de como la de depende mucho del valor de . Un
problema de redondeo del programa podra arruinar el resultado. Se puede comprobar que el
determinante es mucho ms pequeo que la norma.
| |
(5.6)
Cuando se tiene una matriz mal condicionada se debe evitar que los valores problemticos
(nmeros muy pequeos) estn en la diagonal. Se debe por lo tanto reordenar la matriz en
caso de tener ese problema. Si se quiere ser riguroso en la reordenacin de la matriz se debe
conseguir una matriz lo ms parecido a una matriz diagonal dominante.
Se debe calcular un parmetro de calidad en todas las filas (desde la fila del pvot hasta la
fila n). ste es el cociente entre el valor de la columna y los elementos de la fila.
|
(|
Donde
viene dado por el elemento de la columna (
[
].
y
viene dado por
- 46 -
|
|)
(5.7)
[
] donde es la posicin del pvot)
Mtodos numricos
Para garantizar que la matriz est bien condicionada se cambia la fila del pvot por aquella fila
que tenga mayor.
Otro mtodo menos riguroso consiste en buscar el mximo valor de los elementos de la
columna por debajo del pvot y cambiar la fila por la del pvot. Aunque de esta forma no se
garantiza que no haya nmeros muy grandes en el resto de la fila.
5.3.
Descomposicin LU
La descomposicin LU (donde LU viene de las siglas inglesas Lower-Upper) es una forma de

factorizacin de una matriz como el producto de una matriz triangular inferior y una superior.
Esto puede ser til cuando se debe resolver varios sistemas de ecuaciones donde la matriz
no vara y lo que vara es el vector . Un ejemplo sera tener una estructura y se deben calcular
varios estados de carga distintos.
(5.8)
) (
En este libro se estudian dos mtodos de descomposicin LU. Ambos dependen de qu matriz
( o ) tenga unos en su diagonal. El mtodo Doolittle introduce unos en la matriz (
)
y el mtodo Crout tiene los unos en la matriz (
).
Una vez se tienen las matrices y se resuelve el sistema
y luego
. Como
son diagonales, no hace falta hacer el mtodo de Gauss para obtener la solucin.
(
5.4.
(5.9)
Doolittle
En el siguiente ejemplo se puede ver como haciendo el mtodo Doolittle es anlogo a hacer el
mtodo de Gauss. Se empieza con las dos matrices y de ejemplo.
4
4
(5.10)
) (
44 )
4
4
4
En los elementos de la matriz

eliminacin de Gauss.
(5.11)
4
4
4
4
44 )
aparecen las operaciones que se hacen al utilizar el mtodo de
- 47 -
Mtodos numricos
Para obtener las matrices con el mtodo Doolittle se hacen las operaciones similares a la
triangulacin de Gauss. Se triangula la matriz dejando en los ceros el multiplicador.
Como ejemplo se parte de la siguiente matriz :
(5.12)
Se empieza con el pvot de la primera columna. En los elementos

multiplicador (valores encuadrados).
se deja el valor del
(5.13)
(5.14)
Se hace lo mismo para el siguiente pvot.
Por lo tanto las matrices y
son:
(
5.5.
(5.15)
Crout
De forma similar al mtodo Doolittle se multiplican dos matrices

forma de la matriz .
genricas para ver la
4)
) (
4
(5.16)
44
4
4
(5.17)
4
4
4
4
44 )
De la primera columna se pueden sacar las variables

y utilizando la primera fila se pueden
obtener las variables
. Se reduce el tamao de la matriz para obtener los dems valores.
4
4
4
- 48 -
4
4
) (5.18)
4
4
44
Mtodos numricos
De forma similar en la primera columna se pueden obtener las variables

, ya que los
productos a los que suman estas variables contienen valores conocidos. De la primera fila se
resuelven las variables
utilizando los valores conocidos. Se vuelve a reducir la matriz.
4
(
4
4
4
4
4
(5.19)
44
Se pueden resolver
y 4 y luego 4 . Este proceso se va repitiendo con cada submatriz
utilizando la primera columna para obtener las variables
y la primera fila para obtener las
variables
.
De forma general si se tiene la siguiente matriz
y de (hasta el pvot ):
modificada para ir obteniendo los valores de
(5.20)
(
Los valores
(donde son los elementos de la columna a partir de
siguiente forma:
) se obtienen de la
Los valores de
siguiente forma:
(5.21)
(donde son los elementos de la fila por detrs de
) se obtienen de la
5.6.
(5.22)
Matrices dispersas
Una matriz dispersa es una matriz donde la mayor parte de los elementos son ceros. Existen
mtodos para agilizar la resolucin de sistemas de ecuaciones disminuyendo la carga
computacional y el tamao consumido en memoria para almacenar todos los valores.
Almacenamiento Skyline
Se generan vectores en cada fila de la matriz dispersa tomando desde el primero hasta el
ltimo elemento no nulo de cada fila. Es posible que hayan ceros entre los elementos
seleccionados. Por ejemplo, se quiere almacenar la siguiente matriz:
(5.23)
(
- 49 -
Mtodos numricos
Los cuatro vectores que se forman son:
{ }
{ }
{ }
{ }
{ }
(5.24)
Se escriben todos estos valores en un vector contiguo. De esta forma se almacenan solo
elementos de los
que tiene la matriz.
Para saber como estn ordenados los valores del vector se necesitan dos vectores punteros. El
vector indica la posicin del primer valor no nulo de la fila y el vector indica la cantidad de
valores que hay en esa fila.
(5.25)
{ }
{ }
Alternativamente en vez del vector se puede utilizar otro vector

que posicin del vector empieza la siguiente fila.
donde se define a partir de
(5.26)
{
Si por ejemplo que se quiere recuperar la tercera fila se va al vector o . Estos vectores
indican que se tienen tres elementos y que empiezan a partir de la quinta posicin del vector
de valores. Adems gracias al vector se sabe que los valores empiezan a partir de la tercera
columna. Por lo tanto:
(
(5.27)
Compress Space Row
En este mtodo solo se almacenan los elementos no nulos. En el caso de tener algn cero en la
diagonal tambin se tendra que almacenar. De forma similar al mtodo anterior se utilizan
tres vectores donde el primero es para almacenar los valores de las matrices. Adems se utiliza
un vector que indica la posicin de la columna del elemento y un vector que indica en que
posicin del vector de valores se encuentra el salto de lnea.
Utilizando la matriz de ejemplo
de la ecuacin (5.23) se definen los tres vectores:

(
)
(
(5.28)
En el vector puntero se puede introducir un valor adicional que define la posicin de la fila
siguiente del valor que ya no existira en . No es necesario pero se hace por comodidad.
- 50 -
Mtodos numricos
Si por ejemplo se quiere recuperar la tercera fila de se ira primero al vector puntero que
indica que en la tercera fila aparecen los valores y del vector
( y ). Utilizando el
vector
se sabe que estos valores estn en las columnas y respectivamente. Por lo tanto:
(
(5.29)
Matriz banda
Una matriz banda es una matriz donde los valores no nulos son confinados en un entorno de la
diagonal principal. Se forma una banda de valores no nulos que completan la diagonal
principal y algunas diagonales en cada uno de sus costados.
El ancho de banda de la matriz es el nmero de columnas de elementos no nulos en las filas
centrales. Por ejemplo una matriz
con un ancho de banda de sera:
4
4
44
(5.30)
4
No es necesario almacenar todos los ceros de la matriz, se pueden guardar, por ejemplo, los
datos de la matriz anterior en una matriz reducida
.
(5.31)
4
El ancho de la matriz reducida es igual al ancho de banda y la columna central contiene los
elementos de la diagonal principal.
5.7.
Mtodo del gradiente conjugado
El mtodo del gradiente conjugado es un algoritmo para resolver numricamente sistemas de

ecuaciones lineales cuyas matrices son simtricas y definidas positivas.
Una matriz definida positiva es una matriz tal que para cualquier vector
nulos cumpla
.
de elementos no
Se utiliza para definir la aproximacin de la solucin real . Si se cumplen las condiciones de

la ecuacin (5.32) entonces tambin se cumple la ecuacin (5.33).
(5.32)
- 51 -
Mtodos numricos
( )
(5.33)
Por lo tanto ( ) es el mnimo de esa funcin, es decir:

( )
( )
(5.34)
Utilizando notacin indicial se puede demostrar la afirmacin anterior.

( )
(5.35)
(5.36)
Derivando la expresin respecto a .

(
Debido a que la matriz
es simtrica los trminos dentro de los parntesis son iguales.
(5.37)
El extremo coincide con la solucin del sistema
La aproximacin es igual a la solucin del sistema ms un error:
Por lo tanto y recordando que

(
(5.38)
:
)
( )
(5.39)
Se llega a la conclusin que siempre que se introduzca la solucin aproximada el valor de

mayor, por lo que la solucin real coincide con el mnimo.
es
Por lo tanto encontrando el mnimo se obtiene la solucin real. El mtodo del descenso
mximo elige la direccin ms rpida de descenso para aproximarse a la solucin. Si se hace
eso en cada iteracin al final se llega al mnimo.
Se llama al error de la iteracin
. Tambin se define el residuo
. El
objetivo es que tanto como
sean cero. Segn la ecuacin (5.37) se puede ver que el
gradiente de la funcin es el residuo.
(5.40)
- 52 -
Mtodos numricos
Se puede tambin relacionar el residuo con el error.

(5.41)
La matriz
representa la matriz de transformacin lineal entre el error y el residuo
Empezando con una aproximacin lineal

la siguiente aproximacin
movindose en direccin del gradiente y en sentido opuesto.
se obtiende
(5.42)
Se debe obtener el mnimo siguiendo la direccin del movimiento.

+
(5.43)
Utilizando la regla de la cadena queda:

+
(5.44)
Se busca que el residuo de la siguiente iteracin sea cero, por lo tanto:

(
)]
(5.45)
Para reducir el nmero de operaciones se deben evitar los productos de matriz por vector. A
partir de la ecuacin (5.42) se tiene:
(
(5.46)
El nuevo residuo se puede obtener a partir del anterior y la operacin

no se tiene que
repetir. El proceso iterativo bsico se puede ver esquematizado en la Figura 5.1.
+
+
Figura 5.1. Esquema iterativo bsico del mtodo.
- 53 -
Mtodos numricos
Este esquema permite obtener una solucin rpida si las curvas de nivel son ms o menos
circulares. Si tienen forma de elipses alargadas, el esquema puede tardar mucho en obtener la
solucin del sistema.
Para aproximarse mejor a la solucin se debe buscar una direccin ortogonal a todas las
direcciones anteriores, asegurndose as que solo se pasa una vez por la misma direccin.
Estando por ejemplo en la primera iteracin, la nueva aproximacin es:
(5.47)
El error en la direccin de ortogonalidad es nulo (
iteraciones:
(
). Si esto se cumple en todas las
(
Pudiendo obtener la constante
(5.48)
.
(5.49)
El problema es que el error depende de la solucin pero esta no se conoce. Se debe por lo
tanto utilizar el residuo en vez del error. Se debe aplicar la transformacin del error por el
residuo en un espacio cuya mtrica sea:
(5.50)
Tambin hay que asegurarse de que las direcciones son ortogonales entre s.
(5.51)
El nmero de direcciones que se pueden tener es igual a la dimensin del sistema. ). De esta
forma se asegura que un sistema de
ecuaciones se obtiene la solucin exacta en
iteraciones (sin tener en cuenta errores de redondeo).
Se puede obtener la constante
para la primera iteracin de la siguiente forma:

(
)
(5.52)
Siendo la nueva aproximacin
) no se calcula desde el principio si no que se van

La secuencia de los vectores (
calculando a medida que se hacen las iteracin. En el caso de la primera iteracin este vector
es simplemente:
(5.53)
- 54 -
Mtodos numricos
Para la siguiente iteracin se debe conseguir que

componente en la direccin
para asegurarlo.
sea ortogonal a
. Se elimina la
(5.54)
Donde
es una constante y se obtiene utilizando la condicin de ortogonalidad.

(
)
(5.55)
Por lo tanto
es:
(5.56)
Para las siguientes direcciones se debe asegurar que son ortogonales a las anteriores es decir:
(5.57)
Pero mediante una demostracin que no se va a realizar en este libro se puede llegar a la
conclusin que todos las constantes
son cero para
. Pudiendo utilizar la
ecuacin (5.56) para obtener el valor de .
El esquema iterativo se presenta en la Figura 5.2.
Figura 5.2. Esquema iterativo del mtodo.

Aprovechando la ortogonalidad de las derivadas de bsqueda se puede reescribir el esquema
anterior de forma que solo sea necesario un producto de matriz por vector. El siguiente
esquema es el ms utilizado ya que se reducen el nmero de productos de matriz necesarios.
+
+
Figura 5.3. Esquema iterativo ms utilizado del mtodo.
- 55 -
5.8.
Mtodos numricos
Ejemplo de aplicacin del mtodo del gradiente conjugado
Como ejemplo se considera el siguiente sistema:

[
]{ }
{ }
(5.58)
Se toma como aproximacin inicial:

{ }
(5.59)
Lo primero que se tiene que calcular es el residuo inicial.

{ }
Al ser los valores iniciales el residuo es igual a
]{ }
(5.60)
.
{
(5.61)
Lo siguiente que se calcula es la direccin de la primera iteracin

{
}{
}
(5.62)
}[
]{
Por lo tanto la solucin al hacer una iteracin es:

{ }
(5.63)
Y se calcula el nuevo residuo.

{
Al hacer la nueva iteracin se calcula la constante
]{
Se calcula
(5.64)
}{
}
(5.65)
}{
.
{
- 56 -
(5.66)
Mtodos numricos
}{
}
(5.67)
4{
}[
]{
Finalmente se calcula , como la dimensin del sistema es dos y esta es la segunda iteracin,
el resultado es el exacto (ya que no se ha redondeado ningn resultado anterior).
{
- 57 -
{ }
(5.68)
5.9.
Mtodos numricos
Programas
Programa 1. Resolucin de un sistema mediante Gauss

El programa debe resolver un sistema lineal, considerando que la matriz est bien
condicionada. Se crea una subrutina que resuelve el sistema.
Se deben crear dos variables integer para los bucles do. Como convenio el elemento de la
diagonal a la que se le quiere hacer ceros por debajo se llama pvot. Se crea otra variable mult
donde se almacena el multiplicador de cada fila.
subroutine solver(a, b, n)
implicit none
integer, intent(in) :: n
real, intent(inout) :: b (n), a(n,n)
integer :: row, pivot
real :: mult
Se debe crear ahora la matriz diagonal. El primer bucle se encarga de ir cambiando la posicin
del pvot y va desde la primera posicin hasta la penltima. El segundo bucle se encarga de ir
cambiando los valores de las filas de por debajo del pvot en ceros, por lo tanto ste bucle
empieza en la siguiente fila del pvot y acaba en la ltima fila.
!Triangulate the matrix
do pivot = 1, n-1
do row = pivot+1, n
Una vez dentro del segundo bucle se deben ir convirtiendo los elementos de la columna en
ceros. Primero se calcula el multiplicador que es igual al elemento de la fila dividido por
elemento de la diagonal.
Para utilizar el convenio de numeracin que sigue Fortran se utiliza al nombrar elementos de la
matriz se utiliza el primer valor para la columna y el segundo para la fila, siendo el contrario de
lo que se suele usar, por lo que se deber enviar a la subrutina la funcin transpuesta.
Seguido, a la fila dada se le resta la fila del pvot multiplicada por el multiplicador. Esto solo se
hace para los elementos que estn una columna por detrs de la del pvot, no es necesario
modificar los elementos por debajo del pvot ya que se sabe que esa operacin da cero (y no
es necesario poner esos ceros). Se hace la misma operacin para el vector .
do row = pivot+1, n
mult = a(pivot, row) / a(pivot,pivot)
a(pivot+1:n,row) = a(pivot+1:n,row) - mult * a(pivot+1:n,pivot)
b(row) = b(row) - mult * b(pivot)
end do
- 58 -
Mtodos numricos
Una vez se tiene la matriz triangular se pueden obtener las soluciones. La primera solucin es
trivial de obtener. En este programa el propio vector se va modificando para ir introduciendo
las soluciones.
!Obtain solutions
b(n) = b(n) / a(n,n)
Se debe hacer un bucle para obtener las dems soluciones. Se parte de la penltima fila y se
llega hasta la primera (restando uno al valor de la fila en cada iteracin). En cada iteracin del
bucle se obtiene un nuevo resultado.
Una vez triangulada la matriz, el sistema queda de la siguiente forma:
( )
( )
( )( )
( )( )
( )
( )( )
( )
){
(5.69)
Si por ejemplo se quiere obtener la antepenltima solucin lo primero que se hace es aislar la
variable que se quiere encontrar ( ( )( )
). Para ello se pasa del otro lado los
trminos de la matriz multiplicando a las soluciones ya conocidas (en este caso y ).
Por lo tanto la ecuacin queda:
( )( )
( )( )
( )
(5.70)
La operacin ( )( )
equivale a hacer el producto escalar de los
( )
elementos de la fila que estn por detrs del pvot y de los elementos del vector solucin por
debajo de la fila del pvot.
Una vez se obtiene el resultado de la parte de la derecha de la ecuacin (5.70) simplemente se
divide por ( )( ) para obtener la solucin.
do row=n-1,1,-1
b(row) = b(row) - dot_product(a(row+1:n,row), b(row+1:n))
b(row) = b(row) / a(row,row)
end do
end subroutine
El programa principal debe inicializar la matriz
funciona correctamente.
y el vector
y comprobar que la subrutina
La subrutina solo funciona correctamente si la matriz est bien condicionada. Tanto la matriz
como el vector se generan con nmeros aleatorios. Los valores que no estn en la diagonal
que se generen estarn comprendidos entre
. y . y los elementos de la diagonal siempre
- 59 -
Mtodos numricos
sern como mnimo igual al nmero de filas de la matriz por lo que la suma de los elementos
fuera de la diagonal siempre sern menor que los de la diagonal (en cada fila).
program program8
implicit none
integer i, j
real :: a(n,n), aTrans(n,n), b(n), x(n), rand
!Initialize matrix and vector
do i = 1, n
do j = 1, n
call random_number(rand)
a(i,j) = 0.5 - rand
end do
a(i,i) = (1. + rand) * real(n)
b(i) = rand
end do
Se resuelve ahora el sistema. Como ya se dijo antes, en la subrutina se utiliza el convenio de
estructura del fortran por lo que se debe hacer la transpuesta de la matriz para que coincida
que el primer ndice de la matriz sea la columna.
Como la solucin del sistema en la subrutina se escribe directamente en
vector pero con los valores del vector b.
se debe enviar el
!Solve system
aTrans = transpose(a)
x=b
call solver(aTrans, x, n)
Para comprobar que el programa funciona bien se calcula
. Esto en teora tiene que dar
un vector nulo. Se imprime el mximo valor absoluto de ese vector (dando el error ms
grande) y se comprueba que el valor sea prcticamente cero.
La funcin Matmul multiplica las matrices segn el convenio matemtico, primer ndice filas y
segundo ndice columnas.
!Errors
x = matmul(a, x) - b
print *, 'If the code is correct this is a small number: ', maxval(abs(x))
end program
Nota, la subrutina modifica tanto la matriz como el vector que se enva. El vector es ya la
solucin (que se ha almacenado en ) pero la matriz queda triangulada. Por suerte en vez de
enviar la matriz se ha enviado la matriz aTrans.
- 60 -
Mtodos numricos
Programa 2. Sistema con matriz mal condicionada

En este programa se trabaja con una matriz mal condicionada. Se debe por lo tanto
reorganizar los elementos de la matriz para obtener un buen resultado. En modificar las filas
de la matriz y del vector se utiliza un vector llamado puntero donde se almacena la
posicin de las filas. Por ejemplo, se tiene una matriz
y un vector de puntero
que
inicialmente son:
(
{ }
(5.71)
Si se quiere cambiar la primera fila por la tercera simplemente hay que cambiar el valor del
vector puntero, dejando la matriz y el vector de la siguiente forma:
(
As se sabe que en la primera fila de la matriz

de la matriz , aunque la matriz no exista.
{ }
(5.72)
estn situados los elementos de la tercera fila
De forma similar al programa anterior se crea una subrutina que resuelve el sistema. En este
caso se crea adems un vector puntero (point) y lo primero es inicializar los valores.
subroutine solveMatrix(a, b, n)
implicit none
integer :: row, pivot, point(n), i, pos_row, posPiv
real :: mult, x(n)
!Initialize point vector
do row=1,n
point(row)=row
end do
Para reorganizar la matriz se utiliza un mtodo menos riguroso que consiste en poner el
nmero ms grande que haya por debajo del pvot. Esto no garantiza que la matriz est
perfectamente condicionada pero es ms rpido.
do pivot = 1, n-1
!Organize matrix
mult = 0.
do row = pivot,
if (abs(a(pivot,point(row))) .GT. mult) then
i = row
mult = abs(a(pivot,point(row)))
end if
end do
- 61 -
Mtodos numricos
Se tiene ahora la posicin de la fila que se quiere cambiar por la del pvot. Se debe por lo
tanto intercambiar en el puntero el valor de estas dos filas.
row = point(pivot)
point(pivot) = point(i)
point(i) = row
Se utiliza la variable posPiv sirve para guardar la posicin del pvot y no tener que utilizar
todo el rato point(pivot).
posPiv = point(pivot)
La parte del cdigo que triangula la matriz es similar a la del programa anterior. Hay que tener
cuidado en seleccionar bien la fila ya que sta puede haber sido cambiada por otra.
!Make zeros under Pivot
do row = pivot+1, n
posRow = point(row)
mult = a(pivot, posRow) / a(pivot,posPiv)
a(pivot+1:n,posRow) = a(pivot+1:n,posRow) - mult * a(pivot+1:n,posPiv)
b(posRow) = b(posRow) - mult * b(posPiv)
end do
end do
De forma similar, el cdigo que obtiene los resultados se tiene que modificar para que
seleccione bien las filas que se deben usar.
!Obtain Results
x(n) = b(point(n)) / a(n,point(n))
do row = n-1,1,-1
posRow = point(row)
x(row) = b(posRow) - dot_product(a(row+1:n,posRow), x(row+1:n))
x(row) = x(row) / a(row,posRow)
end do
b=x
end subroutine
Se crea ahora el codigo del programa principal. El codigo es similar al del programa anterior. Se
tiene un generador de matrices que genera una matriz mal condicionada. Los valores de la
matriz fuera de la diagonal principal varan entre -0.5 y 0.5 y los de la diagonal son del orden
de
.
- 62 -
Mtodos numricos
program program9
implicit none
integer, parameter :: size = 20
integer i, j
real :: a(size,size), aTrans(size,size), b(size), x(size), rand
!Generate matrix
do i = 1, size
do j = 1, size
a(i,j) = 0.5 - rand !Number between -0.5 and 0.5
end do
a(i,i) = rand * 1.E-5
!Very small number for the diagonal
b(i) = rand
!Number between 0. and 1.
end do
El sistema resuelve las matrices con el convenio de numeracin de matrices de Fortran (como
en el programa anterior). Se debe por lo tanto enviar la transpuesta de la matriz a la subrutina.
!Solve system
x=b
call solveMatrix(aTrans, x, size)
Se comprueba el resultado haciendo la operacin
absoluto, que indica el mayor error.
y buscando el mximo valor
!Check results
print *, 'If the code is correct this is a small number:', maxval(abs(x))
end program
- 63 -
Mtodos numricos
Programa 3. Doolitle
Para resolver un sistema utilizando el mtodo Doolitle (con unos en la diagonal de la matriz )
el programa tiene que descomponer primero la matriz . El programa se escribe para poder
resolver una matriz bien condicionada.
Tanto la matriz como la matriz
se pueden guardar en la misma matriz (en este caso
modificando la propia matriz . El cdigo que consigue las dos matrices es muy similar al que
triangula la matriz en el Programa 1. La diferencia es que se introducen los valores de los
multiplicadores en los elementos que son nulos.
subroutine luDecomposition(a, n)
implicit none
real, intent(inout) :: a(n,n)
real :: mult
do pivot = 1, n-1
do row = pivot+1, n
mult = a(pivot, row) / a(pivot,pivot
a(pivot+1:n,row) = a(pivot+1:n,row) &
- mult * a(pivot+1:n,pivot)
a(pivot,row) = mult
end do
end do
end subroutine
Se crea ahora una subrutina que resuelva el sistema utilizando las matrices
en la matriz ). Se resuelve primer
seguido de
(almacenadas
subroutine luSustitution(a, b, n)
implicit none
real, intent(inout) :: b (n)
real, intent(in) :: a(n,n)
integer :: row, i
!Ly = b
do row = 1, n
b(row) = b(row) &
- dot_product(a(1:row-1,row),b(1:row-1))
end do
!Ux = y
do row = n, 1, -1
b(row) = b(row) &
- dot_product(a(row+1:n,row),b(row+1:n))
end do
end subroutine
- 64 -
Mtodos numricos
El programa principal es parecido a los anteriores programas que resuelven sistemas de

ecuaciones lineales. La matriz que se genera est bien condicionada. En este programa se debe
llamar primero a la subrutina que se encarga de generar las matrices y y luego se obtiene
el resultado del sistema.
program program10
implicit none
integer i, j
!Generate matrix
do i = 1, n
do j = 1, n
a(i,j) = 0.5 - rand ! A number between -0.5 and 0.5
end do
a(i,i) = 0.1 * (1. + rand) * real(n) ! Good matrix
b(i) = rand ! A number between 0. and 1.
end do
!Solve system
x=b
call luDecomposition(aTrans, n)
call luSustitution(aTrans, x, n)
!Check results
end program
- 65 -
Mtodos numricos
Programa 4. Crout
En este programa se resuelve un sistema de ecuaciones lineales utilizando el mtodo de
descomposicin de Crout. De forma similar al programa anterior, primero se descompone la
matriz del sistema y luego se usa esa matriz para resolver el sistema.
La primera subrutina descompone la matriz. Se considera que la matriz est bien condicionada.
Se usa un bucle para ir moviendo el pivot e ir obteniendo los valores de las matrices y .
subroutine croutDescomp(a, n)
implicit none
integer :: row, column, i
do i = 1, n
De forma general si se tiene la siguiente matriz
y de (hasta el pvot ):
modificada para ir obteniendo los valores de
(5.73)
(
Los valores
(donde son los elementos de la columna a partir de
siguiente forma:
) se obtienen de la
(5.74)
El sumatorio es anlogo a hacer el producto escalar entre el vector que contiene los elementos
de de la fila a la izquierda del elemento en y el vector que contiene los elementos de por
encima del pvot.
!Obtain L
do row = i, n
a(row,i) = a(row,i) - dot_product(a(row,1:i-1),a(1:i-1,i))
end do
Los valores de
siguiente forma:
(donde son los elementos de la fila por detrs de
) se obtienen de la
- 66 -
(5.75)
Mtodos numricos
De forma similar, el sumatorio se traduce en el cdigo en un producto escalar entre los

elementos a la izquierda del pvot y los elementos por encima del elemento en .
!Obtain U
do column = i + 1, n
a(i, column) = a(i, column) dot_product(a(i,1:i-1),a(1:i-1,column))
a(i, column) = a(i, column) / a(i,i)
end do
end do
end subroutine
La segunda subrutina calcula la solucin del sistema utilizando la matriz descompuesta de
Crout. Esta subrutina es muy parecida a la utilizada en el programa anterior. La diferencia con
Doolitle es que la matriz ya no tiene unos en la diagonal por lo que la divisin por los
elementos de la diagonal se hace en el primer sistema
y en cambio la matriz s que
tiene unos en la diagonal.
subroutine croutSust(a, b, n)
implicit none
integer :: row, i
!Ly = b
do row = 1, n
b(row) = b(row) - dot_product(a(row,1:row-1), b(1:row-1))
end do
!Ux = y
do row = n, 1, -1
b(row) = b(row) - dot_product(a(row,row+1:n),b(row+1:n))
end do
end subroutine
El programa principal es parecido a los programas anteriores. Primero genera una matriz bien
condicionada, luego llama a las subrutinas que resuelven el sistema y finalmente calcula el
error.
La diferencia entre ste programa y los dems es que en ste no se hace la transpuesta de la
matriz. Se hace una copia de la matriz para poder luego calcular el error.
program program11
implicit none
integer i, j
real :: a(size,size), aCopy(size,size), b(size), x(size), rand
- 67 -
Mtodos numricos
do i = 1, size
do j = 1, size
end do
a(i,i) = 0.1 * (1. + rand) * real(size) ! Good matrix
end do
aCopy = a
x=b
call croutDescomp(aCopy,size)
call croutSust(aCopy, x, size)
end program
- 68 -
Mtodos numricos
Programa 5. Matriz banda

El objetivo del programa es implementar el mtodo de eliminacin de Gauss a una matriz
Banda, reduciendo el nmero de operaciones en los elementos que se saben que son nulos.
Se define la matriz del sistema como una matriz reducida a(-d:d,size). Siguiendo el convenio
de Fortran el primer ndice indica las columnas y el segundo las filas. Los elementos de la
diagonal estn situados en la columna y el ancho de banda de la matriz es
.
La subrutina que resuelve el sistema es parecida a la del Programa 1, primero se triangula la
matriz del sistema y luego se obtienen los resultados.
Se tiene que tener mucho cuidado con las primeras y ltimas filas, ya que stas no tienen
tantos valores como el ancho de banda. Cada vez que se escribe un bucle o se define un vector
de fila se tiene que utilizar la funcin min() para que devuelva como mucho el nmero de
elementos del ancho de banda o si hay menos, el nmero de elementos disponibles.
Se toma por ejemplo una matriz con un ancho de banda de e un punto intermedio. El
subndice indica la columna y el superndice indica la fila, en el ejemplo se mira la matriz a
partir de la fila . Los elementos de la diagonal principal tienen como subndice .
7
8
(5.76)
Se puede ver que solo se necesitan modificar las filas que hay por debajo del pvot. Adems
solo se pueden restar elementos de la fila del pvot a las dems filas.
subroutine gaussBand(a, b, d, n)
implicit none
integer, intent(in) :: d, n
real, intent(inout) :: a(-d:d,n), b(n)
integer pivot, row, disp
real mult
!Triangulate matrix
do pivot = 1, n - 1
do row = pivot + 1, min(pivot + d, n)
Como ya se ha dicho antes la funcin min(pivot + d, n) se utiliza para asegurarse de que el
programa no busca valores que estn fuera de la matriz.
- 69 -
Mtodos numricos
Para triangular la matriz se tiene que tener cuidado en definir bien los rangos de los vectores.
La matriz reducida no est escrita en el programa como la matriz de la ecuacin (5.76). Est
escrita de la siguiente forma:
(5.77)
)
A diferencia del Programa 1 los elementos que se eliminan no estn debajo del pvot. En el
caso del ejemplo se deben eliminar los elementos 7 y 8 . Para ello se define la variable
disp que indica el nmero de filas que hay entre la fila y el pvot. ste valor no puede superar
por lo que tambin es til para poder definir rangos de columnas.
disp = row - pivot
mult = a(-disp,row) / a(0, pivot)
a(1-disp:d-disp,row) = a(1-disp:d-disp,row) - &
mult * a(1:d,pivot)
end do
end do
De forma similar, para resolver las variables, se tiene que tener cuidado de no salirse de los
rangos de la matriz (utilizando disp = min(d, n - row)) y de definir bien los rangos de los
vectores.
Una vez triangulada la matriz, se obtiene una matriz reducida donde se tienen ceros a la
izquierda de la columna central (que contiene los elementos de la diagonal principal).
(5.78)
Por lo tanto el producto escalar como mucho se hace utilizando un vector de dimensin que
siempre empieza a partir de la columna . En el caso de las ltimas filas se debe tener cuidado
de no utilizar elementos que no existen.
Se utiliza la variable disp para obtener el nmero mximo de columnas que se tienen a la
derecha del pvot.
- 70 -
Mtodos numricos
!Solve x
do row = n, 1, -1
disp = min(d, n - row)
b(row) = b(row) - dot_product(a(1:disp,row),b(row+1:row+disp))
b(row) = b(row) / a(0,row)
end do
end subroutine
El programa principal es parecido a los otros programas. Se define la matriz
de forma
distinta ya que sta no es una matriz cuadrada. Se genera la matriz de forma que est bien
condicionada.
Program program12
implicit none
integer, parameter :: size = 50, d = 5
integer i, j, left, right
real :: a(-d:d,size), aCopy(-d:d,size), b(size), bCopy(size), x(size), rand
do i = 1, size
do j = -d, d
a(j,i) = 0.5 - rand ! A number between -0.5 and 0.5
end do
a(0,i) = (1. + rand) * real(size) !Good matrix
b(i) = rand !A number between 0. and 1.
end do
aCopy = a
x=b
!Solve
call gaussBand(aCopy, b, d, size)
bCopy = b
Como la matriz
operacin
que se ha generado es la matriz reducida no se puede hacer directamente la

. Se debe hacer la operacin para cada fila de la matriz .
!Check results
bCopy = b
do i = 1, size
left = min(d, i - 1)
right = min(d, size - i)
x(i) = dot_product(a(-left:right, i),bCopy(i-left:i+right)) - x(i)
end do
end program
- 71 -
Mtodos numricos
6. Resolucin numrica de sistemas no lineales

6.1.
Mtodo de Newton para sistemas no lineales
Utilizando sistemas de elementos finitos se obtiene un sistema de ecuaciones que no tienen

por qu ser lineales. Se puede extender el mtodo de Newton para resolver sistemas
multivariables.
Para que se pueda resolver el problema se necesitan tantas ecuaciones como incgnitas, que
cumplan que ( )
donde
, y adems unos valores iniciales .
(
El residuo es el valor que se obtiene al poner las soluciones

la solucin del sistema entonces es nulo.
(6.1)
en las funciones ( ). Si
es
De forma similar al mtodo de Newton-Raphson, se utiliza una aproximacin mediante series

de Taylor para aproximar linealmente a .
( )
( )
( ) (
(6.2)
La matriz de derivadas ( ) se suele escribir como matriz . Por ejemplo en los problemas
de elementos finitos estructurales esta matriz es la matriz de rigidez. Los elementos de la
matriz son:
( )
( )
( )
( )
( )
( )
( )
(6.3)
( )
( )
( )
)
Para calcularla se necesitan hacer muchas derivadas parciales y este es un proceso caro por lo
que existen mtodos que buscan reducir al mximo el clculo de esa matriz, por ejemplo, el
mtodo de cuasi Newton.
El objetivo del mtodo es encontrar la solucin
a la ecuacin (6.2), se elige tal que:
tal que ( ) sea cero. Por lo tanto, volviendo
( ) (
- 72 -
(6.4)

Como la matriz
inversa.
Mtodos numricos
es cuadrada se puede resolver el sistema, siempre que la matriz
tenga
(6.5)
En la prctica no se debe usar la inversa de la matriz ya que el clculo es extremadamente

costoso. Se puede resolver la ecuacin resolviendo primero un sistema de ecuaciones lineales.
Se define
como
. El sistema lineal que se resuelve es el siguiente:
(6.6)
Al obtener
se puede resolver fcilmente la nueva iteracin.

(6.7)
- 73 -
Mtodos numricos
7. Ecuaciones diferenciales, problemas de valor inicial

7.1.
Tipos de ecuaciones diferenciales
Una ecuacin diferencial es una ecuacin en la que intervienen derivadas de una o ms

funciones desconocidas. Resolviendo la ecuacin diferencial se obtiene la funcin desconocida.
Dependiendo del nmero de variables independientes respecto de las que se deriva, las
ecuaciones diferenciales pueden ser:
Ordinarias: aquellas que contienen derivadas respecto a una sola variable

independiente.
Parciales: aquellas que contienen derivadas respecto a dos o ms variables.
El orden de la derivada ms alta en una ecuacin diferencial se denomina orden de la

ecuacin. En cambio el grado de la ecuacin es la potencia de la derivada de mayor orden que
aparece en la ecuacin, siempre y cuando la ecuacin est en forma polinmica, de no ser as
se considera que no tiene grado.
Las ecuaciones diferenciales que se estudian en este tema son problemas de valor inicial. Se
busca la solucin numrica de una ecuacin diferencial ordinaria de primer orden de la forma
(
) con una condicin inicial ( ). Ecuaciones de rdenes superiores se pueden
transformar en sistemas de ecuaciones diferenciales de primer orden.
( ), siendo una ecuacin
Un ejemplo tpico de mecnica es la ecuacin diferencial
diferencial ordinaria de segundo orden. Se busca la solucin ( ), es decir, utilizando la

expresin de las fuerzas sobre una masa se busca la posicin que va teniendo a lo largo del
tiempo.
7.2.
Mtodo de Euler
El mtodo de Euler es un mtodo para resolver ecuaciones diferenciales ordinarias a partir de

un valor inicial. Es el mtodo ms bsico y explicito para resolver problemas de valor inicial.
Suponiendo que se quiere aproximar la solucin del siguiente problema con un valor inicial:
( )
( ))
( )
(7.1)
Se puede tomar un valor constante de cada intervalo .

(7.2)
Utilizando la aproximacin de primer orden de la serie de Taylor, se puede obtener la

aproximacin de un punto separado por .
+
(7.3)
Los valores son aproximaciones de la funcin en los puntos . El mtodo de Euler es un

mtodo explcito, es decir, la solucin + es una funcin explcita de para
.
- 74 -
Mtodos numricos
El error se propaga con cada intervalo y el error acumulado es del orden .

(7.4)
El error es por lo tanto de primer orden por lo que el mtodo no es recomendable.
7.3.
Ejemplo de resolucin mediante el mtodo de Euler.
Como ejemplo de resolucin con este mtodo se toman los siguientes valores:
( )
(7.5)
Se busca la aproximacin utilizando el mtodo de Euler para obtener ( ). Para empezar se

utiliza un intervalo igual uno.
El mtodo se resuelve utilizando la ecuacin (7.3). Por lo tanto para el tramo de inicio se debe
), en este caso (
)
calcular (
.
(
(7.6)
Con este paso se ha calculado la pendiente de la recta que pasa por el punto inicial y va hasta
el primer punto. El primer punto es por lo tanto:
(
(7.7)
Se hace lo mismo para los siguientes tres puntos
(7.8)
{
La solucin exacta de esta EDO es

(gris) con la aproximada (negro).
. En la siguiente figura se comparan la solucin real
50
40
30
20
10
0
0
0.5
1.5
2.5
3.5
Figura 7.1. Solucin real (gris) y solucin aproximada (negro).
7.4.
Mtodo implcito de Euler
El mtodo implcito de Euler o mtodo hacia atrs de Euler es muy parecido al mtodo de
Euler (que tambin se le llama mtodo hacia adelante) pero difiere en que es un mtodo
- 75 -
Mtodos numricos
implcito. ste mtodo es ms estable que el anterior y permite utilizar intervalos mayores,
aunque como siempre, hay que tener cuidado con que no afecte a la calidad de la solucin.
La diferencia ente los dos mtodos es en aproximacin de la pendiente ( (
(
+ )
).
(7.9)
La nueva aproximacin de + aparece en ambos lados de la ecuacin y por lo tanto se tiene

que resolver una ecuacin algebraica. Se puede por ejemplo el teorema del punto fijo para
resolverlo.
Se puede desarrollar la funcin
costosos.
en serie de Taylor pero hacer derivadas de la funcin es muy
Este mtodo tambin es de orden uno y el error es similar al del mtodo de Euler.
7.5.
Mtodo de Heun
El mtodo de Heun tambin es conocido como el mtodo modificado de Euler. Tambin es

similar al mtodo de Runge-Kutta de dos pasos.
Se calcula primero el valor intermedio de + y luego el valor aproximado + en el siguiente
punto de integracin. En este mtodo se cambia la terminologa ya que deja de ser el
resultado y pasa a ser una primera aproximacin para luego calcular el resultado
(
( (
+ ))
(7.10)
Este mtodo utiliza el mtodo de Euler para calcular una estimacin de las coordenadas del
siguiente punto y, con este dato, se corrige la estimacin original. Considerando que el valor
),
de ( ) en la parte derecha de la ecuacin es la pendiente de la solucin en el punto (
esto se puede combinar con la estimacin de Euler en el siguiente punto para dar la pendiente
( )). La solucin es el punto intermedio
de la lnea tangente en el punto de la derecha (
entre las dos soluciones.
( )
(+ + )
Figura 7.2. Mtodo de Heun de forma grfica.
- 76 -
7.6.
Mtodos numricos
Mtodo de Runge-Kutta de segundo orden
El mtodo de Runge-Kutta de segundo orden se basa en la aproximacin de la serie de Taylor

de segundo orden.
(
( )
( )
( )
(7.11)
La primera derivada se sustituye por la ecuacin diferencial ( )

derivada se obtiene haciendo la derivada de la ecuacin diferencial.
(
( )
). La segunda
(7.12)
La expansin de Taylor se convierte en:

(
(
(
[(
)
)
)
(7.13)
)
]
La expansin de Taylor para dos variables es:

(
(7.14)
Se puede ver que la expresin entre corchetes de la ecuacin (7.12) se puede interpretar
como:
(
))
) (7.15)
Obteniendo:
(
( )
))
(7.16)
Se puede escribir con la connotacin numrica.

(
(7.17)
Donde
(
Se puede ver que para el caso del mtodo de Euler se tiene
))
y
(7.18)
.
La forma explcita general del mtodo de segundo orden de Runge-Kutta asumiendo:

(
Donde
)y
)
(
( )
- 77 -
]
)).
(7.19)
Mtodos numricos
Est claro que esto es una generalizacin del mtodo clsico de Runge-Kutta ya que los
y
coeficientes
cumplen la ecuacin (7.17). Estos coeficientes se
suelen ordenar en una tabla conocida como Butcher tableau, donde se ponen los vectores y
y la matriz de la siguiente forma.
Figura 7.3. Butcher tableau.

Para el mtodo de Runge-Kutta de segundo orden la tabla queda de la siguiente forma.
Figura 7.4. Runge-Kutta de segundo orden.
7.7.
Mtodo de Runge-Kutta de rdenes superiores
Se puede aumentar el orden del mtodo de Runge-Kutta aumentando los pasos que se hacen.
De forma similar a la ecuacin (7.17) la solucin general para orden viene dada por:
( )
(7.20)
(7.21)
Donde
(
(
)
)
Para cada mtodo particular, se debe proveer con el ntegro (nmero de pasos) y los
coeficientes
(para
), b (para
) y
(para
). La
matriz se llama la matriz de Runge-Kutta, mientras que los vectores y son los pesos y los
nodos. Los valores se suelen escribir en el Butcher tableau.
Figura 7.5. Butcher tableau.
- 78 -
Mtodos numricos
Para que el mtodo de Runge-Kutta sea consistente se debe cumplir que:
(7.22)
El siguiente valor ( + ) se determina con el valor actual ( ) ms la media ponderada de los

incrementos, donde cada incremento es el producto del tamao del intervalo ( ) y una
pendiente estimada por la funcin en la parte derecha de la ecuacin diferencial.
Pese que aumentar el orden del mtodo de Runge-Kutta aumenta la precisin del resultado,
estimar la funcin suele ser muy caro, y un problema con un orden debe evaluar veces la
funcin. En general se suelen utilizar rdenes cercanos a o como compromiso entre
precisin y carga computacional.
Como ejemplo el problema de Runge-Kutta de orden viene dado por la siguiente ecuacin:
+
4)
(7.23)
Para que se cumpla que sea un valor promedio de la derivada se debe cumplir que la suma de
los valores que multiplican a los coeficientes sea igual a , en este caso se cumple.
Los coeficientes son:
(
(7.24)
En este caso se tiene que:
es el incremento basado en la pendiente al principio del intervalo, usando

(mtodo de Euler).
es el incremento basado en la pendiente en el punto medio del intervalo, usando
.
.
es tambin el incremento basado en la pendiente en el punto medio del intervalo,
usando
.
.
.
4 es el incremento basado en la pendiente al final del intervalo usando
Haciendo la media ponderada de estos cuatro incrementos se le da ms importancia a los

incrementos en el punto medio del intervalo. Los pesos se escogen de manera que si es
independiente de , por lo que la ecuacin diferencial es equivalente a una simple integral, el
mtodo de cuarto orden es similar a la regla de Simpson.
Como su nombre lo indica este mtodo es de cuarto orden por lo que el error entre intervalos
es del orden de y el error acumulado es del orden de 4 .
- 79 -
7.8.
Mtodos numricos
Mtodo adaptativo de Runge-Kutta
Este mtodo es capaz de ir ajustando el intervalo . Zonas de la solucin que tienen una forma
suave (la pendiente no cambia mucho) no requieren intervalos pequeos mientras que
zonas donde la pendiente cambia rpidamente s que requieren intervalos pequeos ya que si
no la solucin no sera buena.
Implementando este mtodo en un programa se puede automatizar el proceso de seleccin
del intervalo y as agilizar el programa si necesidad de estropear la solucin. Siempre se debe
mantener el error local dentro de unos mrgenes.
Para avaluar el cambio de intervalo se calcula una estimacin del error de truncamiento local
del mtodo de Runge-Kutta de dos rdenes distintos.
Se pueden introducir los dos mtodos en el Butcher tableau, uno de orden
. La tabla se representa de la siguiente manera.
y otro de orden
Figura 7.6. Butcher tableau para el mtodo adaptativo.

El paso de menor orden viene dado por:
(7.25)
Donde son los mismos que para el paso de mayor orden. Se comparan las soluciones dadas
por los dos pasos para calcular el error.
(7.26)
Este error es del orden ( ). Si el error est dentro de unos mrgenes de precisin significa
que la solucin del orden inferior es suficientemente buena (comparada con la de orden
superior) por lo que la curva es suave en ese punto, pudiendo incrementar el intervalo.
Como ejemplo, el mtodo de Runge-Kutta adaptativo ms simple es el que combina el mtodo
de Heun (segundo orden) con el mtodo de Euler (primer orden). La tabla extendida queda:
Figura 7.7. Runge-Kutta adaptativo de menor orden.
- 80 -
7.9.
Mtodos numricos
Esquema de Crank-Nicolson
El esquema de Crank-Nicolson es un mtodo implcito. Viene dado por la siguiente ecuacin:

(
(7.27)
Es un mtodo muy estable pero tambin es muy sensible a perturbaciones

El esquema de Crank-Nicolson es un caso particular de la familia de esquemas que se obtienen
[ ] el peso dado a (
) frente al dado a
ponderando mediante un parmetro
( +
+ ) en la frmula de integracin numrica.
[(
) (
)]
(7.28)
En el caso del esquema de Crank-Nicolson dado por la ecuacin (7.27)

. . . Si se le da
ms peso al segundo trmino se parece ms el mtodo de Euler hacia atrs y se vuelve ms
[ . ].
estable. Por lo general estos mtodos suelen tener
7.10. Mtodo de Runge-Kutta para EDOs de grados superiores

Cuando el orden de la ecuacin diferencial es mayor que uno, se debe convertir la ecuacin
diferencial en un sistema de ecuaciones diferenciales de primer orden. Si se tiene una ecuacin
diferencial de la forma:
(7.29)
Se debe escribir un sistema de ecuaciones diferenciales de la forma:
(7.30)
Por ejemplo, si se quiere resolver un sistema de segundo orden de la forma:

(
(7.31)
Se debe convertir la ecuacin en un sistema de dos ecuaciones tal que:

(7.32)
El sistema de ecuaciones diferenciales queda:
(
(7.33)
Para cada intervalo se calculan de forma separada el siguiente valor de la solucin ( y ). Para
cada EDO se obtienen sus respectivos coeficientes .
Al ser una ecuacin diferencial de segundo orden se deben tener dos condiciones iniciales:
( )
( )
( )
- 81 -
( )
(7.34)
Mtodos numricos
8. Mtodo de diferencias finitas

8.1.
Diferencias finitas en una dimensin.
Una diferencia finita es una expresin matemtica de la forma (

divide la diferencia finita por
se obtiene el cociente diferencial.
). Si se
Se puede discretizar un dominio en diferencias finitas, buscando en esos puntos las soluciones
aproximadas ( ) de un sistema de ecuaciones diferenciales. Se define una malla de una
dimensin como la de la Figura 8.1
Figura 8.1. Discretizacin del dominio en una dimensin.

La solucin ( ) debe cumplir (
para
Aunque la malla no sea uniforme normalmente se pueden hacer transformaciones. En el caso

de tener un dominio sin un orden definido y al que no se le puede aplicar una transformacin,
las diferencias finitas no tienen sentido.
Se busca cambiar las ecuaciones diferenciales por un sistema de ecuaciones lineales donde
solo aparecen las soluciones aproximadas en los nodos. Para ello se deben obtener
aproximaciones de las derivadas en los nodos.
Se utiliza la serie de Taylor para aproximar la funcin en una zona dividida por diferencias
finitas. Se aproximan primero el punto
y el punto
.
+
4)
(8.1)
4)
(8.2)
Se resta la ecuacin (8.2) a la ecuacin (3.1) pero aproximadas hasta el segundo orden.
+
(8.3)
Pudiendo obtener la aproximacin de segundo orden de la derivada primera.

+
(8.4)
Se puede obtener la segunda derivada de la funcin sumando las ecuaciones (3.1) y (8.2).
+
- 82 -
4)
(8.5)
Mtodos numricos
En el caso de estar situados en los nodos extremos no se pueden aplicar estas ecuaciones. Se
podra utilizar la aproximacin de primer orden de la primera derivada:
+
( )
(8.6)
Pero sta no es una buena solucin. La aproximacin de un orden superior requiere tomar el
siguiente nodo. Utilizar el nodo
puede provocar la necesidad de aumentar el ancho de
banda del sistema aumentando el nmero de operaciones. La aproximacin de un punto ms a
la derecha es:
(
(8.7)
Se utiliza multiplica la ecuacin (3.1) por cuatro y se le resta la ecuacin (8.7).

+
+
+
(8.8)
Para el caso de la derivada por la izquierda la metodologa es la misma.
(8.9)
En general los valores de las derivadas por la izquierda son los mismos que los de la derecha
pero si la derivada es impar se deben cambiar los signos (como en el caso de la primera
derivada en las ecuaciones (8.8) y (8.9)).
Se puede aumentar el orden de aproximacin Taylor para obtener expresiones para derivadas
de mayor orden. El problema de aumentar el orden de aproximacin de Taylor es que se
necesitan funciones muy suaves. Si por ejemplo se resuelven las ecuaciones de Euler, que
admiten discontinuidades (ondas de choque), y se utiliza un esquema de alto orden, la
solucin muestra unas oscilaciones en la presin y densidad que no reflejan la realidad.
Para problemas trmicos donde las funciones suelen ser suaves se puede usar un orden alto.
Existen mtodos llamados espectrales que cada nodo toma informacin de todo el dominio.
Pero si la geometra es complicada tampoco se pueden usar rdenes altos.
8.2.
Diferencias finitas en dos dimensiones
El caso bidimensional es parecido al anterior pero esta vez el mallado se hace en dos
direcciones. En general se suele definir un mallado uniforme, con forma rectangular, como el
de la Figura 8.2. El intervalo en las dos direcciones puede ser diferente.
Aunque la geometra del problema no sea rectangular se pueden hacer transformaciones del
mallado. Para geometras complejas se utilizan volmenes estructurados para dividir el
dominio en distintos bloques donde aplicar diferencias finitas. El cdigo escrito por Onera para
problemas aerodinmicos (ELSA) utiliza volmenes finitos estructurados.
- 83 -
Mtodos numricos
( )
(
( )
( )
( )
( )
Figura 8.2. Discretizacin en dos dimensiones.

Las derivadas parciales que solo sean en una direccin son las obtenidas para el caso
unidimensional. Por ejemplo la derivada primera en la direccin es:
+
(8.10)
La derivada cruzada de segundo orden se obtiene utilizando las series de Taylor. Se hace la
derivada en dos pasos:
(
|
(8.11)
Se hace ahora la derivada en la direccin .

|
(8.12)
En general se suelen guardar todos los nodos en un solo vector en vez de una matriz ya que se
necesita resolver un sistema de ecuaciones del tipo
. El valor de la posicin en el
vector es:
(
8.3.
(8.13)
Ejemplo de problema mecnico
En una pelcula llamada Total Recall se muestra un innovativo mtodo de transporte para ir
desde Inglaterra hasta Australia. El mtodo consiste en hacer caer un ascensor por un tnel a
travs del centro de la tierra aprovechndose nicamente de la gravedad. Empezando sin
ningn tipo de velocidad ni de empuje adicional ms que la gravedad, el viaje dura 17 minutos.
Para comprobar si lo que se muestra la pelcula es correcto se hacen las siguientes
suposiciones:
-
La masa de la tierra se distribuye de forma uniforme dentro de una esfera de

.
. El parmetro gravitacional de la tierra es
El tnel es una lnea recta que pasa por el centro de la tierra.
- 84 -

-
Mtodos numricos
La nica fuerza externa actuando en el cuerpo a parte de la gravedad es la friccin

aerodinmica. Se puede computar como
.
. Se podra incluso asumir
que la densidad del aire en el tnel se mantiene constante e igual a la densidad del
aire a nivel del mar.
Se ignoran las fuerzas centrfugas debidas a la rotacin de la tierra y la aceleracin de
Coriolis.
Visto que por lgica la nica forma que el ascensor llegue al otro lado en el caso de haber
friccin aerodinmica se debe tener una velocidad inicial nula. Este problema se puede
resolver analticamente si se considera que no hay fuerzas externas aparte de la gravedad,
pudiendo llegar de un lado al otro de la tierra empezando con velocidad nula.
Utilizando la formulacin adimensional explicada ms adelante se puede obtener la solucin
analtica para el caso de empezar con velocidad nula y sin friccin:
( )
( )
(8.14)
Siendo esta solucin el caso ms favorable, el tiempo que tardara en recorrer toda la tierra
sera de unos
minutos. Se empieza a ver que los guionistas no se han molestado por
investigar un poco de fsica antes de inventar sus mundos de ficcin.
Debido a que los
minutos de cada libre no pueden conseguirse empezando sin velocidad
inicial, el objetivo del problema es calcular la velocidad inicial que se necesitara para poder
llegar en 17 minutos al otro lado de la tierra.
Ecuacin del movimiento
Lo primero que se debe hacer es obtener la ecuacin que gobierna el problema. La ecuacin
del movimiento se basa en la segunda ley de Newton.
(8.15)
Hay dos fuerzas presentes en el ascensor: la gravedad y la friccin aerodinmica.

(8.16)
La friccin se puede simplificar utilizando la siguiente expresin:
(
(8.17)
Considerando la densidad de la tierra constante en todo el tnel. La masa que ejerce una
fuerza sobre el ascensor, en una posicin desde el centro de la tierra es:
(8.18)
- 85 -
Mtodos numricos
La fuerza de gravedad en esa posicin es:

(8.19)
El origen se ha puesto en el centro de la tierra y el inicio del movimiento en
ecuacin diferencial que gobierna el movimiento es finalmente:
] (
. La
(8.20)
Ecuacin adimensional
En general es recomendable adimensionar las ecuaciones antes de resolverlas. En la ecuacin

anterior hay dos parmetros que se deben adimensionalizar: la posicin y el tiempo .
La posicin se adimensionaliza con el radio de la tierra y para el tiempo se define un tiempo de
referencia el cual se le puede dar un valor ms tarde.
(
(
] [
La ecuacin anterior se divide por
(
(
(8.21)
]
)
] (
(8.22)
para que todos los sumandos sean
adimensionales.
] (
Para simplifica la ecuacin anterior se puede elegir un valor de

multiplicado por ningn coeficiente.
(8.23)
de forma que no est
(8.24)
La ecuacin adimensionalizada queda:
] (
(8.25)
Discretizacin
La ecuacin diferencial se discretiza utilizando diferencias finitas. Para el caso de la derivada

segunda, sta se discretiza para los nodos desde hasta
de la siguiente forma:
- 86 -
(8.26)
Mtodos numricos
Para el caso de la primera derivada, la discretizacin queda:
(8.27)
Introduciendo estas dos ecuaciones en la ecuacin (8.25) se obtiene la ecuacin del problema
discretizada.
+
] (
(8.28)
Para simplificar la ecuacin anterior se nombra el trmino constante de la friccin como un

coeficiente .
(8.29)
+
(8.30)
Las condiciones de contorno son la posicin conocida en los extremos.
(8.31)
El sistema de ecuaciones se puede expresar mediante un vector de ecuaciones.
( )
(8.32)
)
El sistema de ecuaciones anterior no es lineal por lo se debe utilizar el mtodo de Newton para
sistemas no lineales para resolverlo. La matriz de derivadas para este sistema es:
( +
( +
(8.33)
Para obtener el resultado de cada iteracin se debe resolver un sistema lineal y una suma
vectorial.
- 87 -
(8.34)
Mtodos numricos
El residuo inicial se obtiene introduciendo los valores iniciales en el sistema de ecuaciones.

Para el primer y ltimo nodo el residuo es cero puesto que la solucin es conocida.
(8.35)
)
Los valores iniciales se pueden calcular obteniendo la solucin analtica en el caso que no haya
friccin aerodinmica. La ecuacin diferencial es una simple de segundo grado.
La solucin es de la siguiente forma, siendo
( )
(8.36)
constantes.
(8.37)
Como condiciones iniciales se puede utilizar la posicin inicial y la posicin final.

( )
(8.38)
( )
(8.39)
Siendo el tiempo final:
(8.40)
El tiempo transcurrido entre cada nodo se define utilizando el tiempo total (

nmero de nodos utilizados para la simulacin
minutos) y el
(8.41)
Por lo tanto los valores iniciales se estiman como:
(8.42)
Estimacin del coeficiente de friccin
La contribucin de la friccin aerodinmica viene dada por un coeficiente (definido en la

ecuacin (8.29)) multiplicado por la velocidad al cuadrado. El parmetro se puede dividir el
coeficiente de friccin del aire
(que se puede considerar del orden de magnitud 1) y el ratio
. Si el aire es respirable
entre la masa de aire dentro del tnel y la masa del ascensor
este nmero no puede ser pequeo conociendo el tamao del tnel. En la pelcula el ascensor
- 88 -
Mtodos numricos
pareca muy grande y para dar un poco de credibilidad a la pelcula se podra considerar que
ese ratio es de orden de magnitud 1. Por lo tanto se define
. .
Velocidad inicial
La velocidad inicial se puede calcular utilizando la aproximacin de segundo orden por la

derecha.
El programa escrito para resolver este problema se detalla en el siguiente apartado.
- 89 -
(8.43)
8.4.
Mtodos numricos
Programas
Programa 6. Ejemplo de problema mecnico

El programa debe resolver un problema de diferencias finitas con un sistema no lineal. Al ser
un sistema no lineal se debe tener un bucle iterativo para ese sistema. Se puede tambin
poner un bucle mayor para hacer un estudio de convergencia de malla, cambiando el tamao
de malla cada vez que obtenga una solucin. La estructura del programa es la siguiente:
Iniciar variables
Generar matrices:
y
Resolver sistema lineal

Obtener nueva solucin

+

Calcular velocidad inicial
Nueva iteracin del

sistema no lineal?
Imprimir resultados
Nuevo tamao
de malla?
Fin
Figura 8.3. Estructura del programa.

Para este programa se crean tres subrutinas: una para iniciar variables, otra para generar las
matrices y y la tercera para resolver el sistema lineal. Se describen primero las subrutinas.
- 90 -
Mtodos numricos
La primera subrutina genera el vector . Debido a que esta variable depende del tamao de la
malla se tiene que hacer cada vez que se cambie el tamao de sta. Se utiliza la ecuacin
(8.42) para obtener estos valores.
subroutine initialValues(x0, n, tref, h)
implicit none
real*8, intent(in) :: tref, h
real*8, intent (out) :: x0(n)
integer i
real*8 t, tn, kn
tn = 1020. / tref
kn = (1. + dcos(tn)) / dsin(tn)
x0(1) = -1.
do i = 2, n - 1
t = dble(i - 1) * h
x0(i) = - dcos(t) + kn * dsin(t)
end do
x0(n) = 1.
end subroutine
La segunda subrutina genera las matrices

calcular las matrices.
y . Se utilizan las ecuaciones (8.33) y (8.35) para
subroutine writeSystem(K, R, x, n, tref, h, ka)

implicit none
real*8, intent (in) :: x(n), tref, h, ka
real*8, intent (out) :: K(3,n), R(n)
integer i
real*8 h2
h2 = 1. / (h * h)
!Write matrix K
K(2,1) = 1.
K(3,1) = 0.
do i = 2, n - 1
K(1,i) = h2 - ka * 2. * (x(i+1) - x(i-1)) * h2
K(2,i) = 1. - 2. * h2
K(3,i) = h2 + ka * 2. * (x(i+1) - x(i-1)) * h2
end do
K(1,n) = 0.
K(2,n) = 1.
- 91 -
Mtodos numricos
!Write vector R
R(1) = 0.
do i = 2, n - 1
R(i) = x(i) + (x(i+1) - 2. * x(i) + x(i-1)) * h2 + &
ka * (x(i+1) - x(i-1)) * (x(i+1) - x(i1)) * h2
end do
R(n) = 0.
end subroutine
La tercera subrutina es la que resuelve el sistema lineal. El sistema est compuesta por una
matriz banda de solo tres columnas por lo que es recomendable utilizar un solver que se
aproveche de esta condicin.
implicit none
real*8, intent(inout) :: a(-d:d,n), b(n)
real*8 mult
!Triangulate matrix
do pivot = 1, n - 1
disp = row - pivot
!Gauss
mult * a(1:d,pivot)
end do
end do
!Solve x
do row = n, 1, -1
end do
end subroutine
La rutina principal se encarga de seguir el esquema de la Figura 8.3, llamando a las 3

subrutinas descritas.
Lo primero que debe hacer es definir las variables que se utilizaran. Se crean una serie de
variables de configuracin del programa.
- 92 -

-
Mtodos numricos
es la constante del termino de friccin, equivale a la k

es el nmero de nodos de la primera malla
es el nmero de veces que se cambia la malla
es el nmero mximo de iteraciones para resolver cada malla
es el valor mximo aceptable en el vector R
program finiteDifferences
implicit none
integer n, i, j, maxIt, maxLoop, kas
real*8, allocatable :: K(:,:), R(:), x(:)
real*8 v, v1, h, tref, ka, error
!Program configuration
ka
= 0.5
!Constant in drag
n
= 1000 !Initial number of nodes
maxLoop = 10
!Maximum number of times the program is runned
maxIt
= 100
!Maximum iteration in Newton's method
error
= 0.00001 !Maximum Error
tref = 6.371E6 * 6.371E6 * 6.371E6 / 3.986E14
tref = tref ** 0.5
El primer bucle es el que se encara de regenerar las mallas. Debe primero crear las matrices K,
R y x. Una vez ha generado esas matrices en memoria se llama a la subrutina que se encarga
de asignar los valores iniciales.
!Loop for number of nodes
do j = 1, maxLoop
allocate (K(3,n), R(n), x(n))
!Initial values for x
h = (1020. / tref) / dble(n - 1)
call initialValues(x, n, tref, h)
v = 0.
Seguidamente, se empiezan las iteraciones que resuelven el problema para la malla dada. El
bucle se termina o bien cuando llega al mximo de iteraciones o cuando el error menor que el
marcado en la variable
.
!Loop for number of iterations
do i = 1, maxIt
!Generate matrix K and vector R
call writeSystem (K, R, x, n, tref, h, ka)
!Solve Kdx = -R
R=-R
call gaussBand(K, R, 1, n)
- 93 -
Mtodos numricos
!Solve x1 = x0 + dx
x=x+R
!Initial velocity
v1 = v
v = (4. * x(2) - 3. * x(1) - x(3)) / (2. * h)
!Print results
if(maxval(abs(R)) .lt. error) then
print*, "Number of nodes: ", n
print*, "Error in R:
", maxval(abs(R))
print*, "Iterations needed: ", i
print*, "Initial velocity: ", "
", v
print*, " "
exit
elseif (i .eq. maxIt) then
print*, "No solution found. "
print*, " "
end if
end do
Una vez se acaba el clculo se le da un nuevo valor a la malla si es necesario borrando antes las
matrices K, R y x.
!Renew discretization
deallocate(K, R, x)
n = 1000 + n
end do
end program
Los resultados generados por el programa anterior son los siguientes:

Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
1000
4.05833953591406877E-010
6
33.901530208195759
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
2000
3.99446362148938426E-010
6
33.988404464699350
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
3000
3.98089342760615747E-010
6
34.006278684062110
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
4000
3.97452197374683662E-010
6
34.012788837112836
- 94 -
Mtodos numricos
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
5000
3.97345468277236172E-010
6
34.015867125092669
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
6000
3.97189273253109707E-010
6
34.017561828242137
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
7000
3.97116818907919676E-010
6
34.018593137328239
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
8000
3.97085218660822430E-010
6
34.019267018567149
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
9000
3.97022337062319620E-010
6
34.019731410085285
Number of nodes:
Error in R:
Iterations needed:
Initial velocity:
10000
3.97022961043059028E-010
6
34.020064936000409
Se puede ver que la velocidad inicial converge hacia unos 34.02. Hay que recordar que el error
es el valor absoluto mximo de la matriz R pero para el clculo de la velocidad inicial se debe
hacer una operacin matemtica que incluye la longitud de malla por lo que el error de la
velocidad es distinto.
La velocidad dada est en unidades adimensionales por lo que para pasarla a unidades
internacionales se debe multiplicar por la longitud de referencia dividida por el tiempo de
referencia.
Se puede ver que la velocidad inicial para que se cumplan los
- 95 -
(8.44)
minutos es desorbitada.
Mtodos numricos
9. Mtodo de elementos finitos

9.1.
Forma fuerte del problema
El mtodo de elementos finitos (MEF) es un mtodo numrico general para la aproximacin de

soluciones de ecuaciones diferenciales parciales, como por ejemplo la ecuacin de Laplace.
(
(9.1)
El MEF permite obtener una solucin numrica aproximada sobre un dominio (medio
continuo) dividido en un nmero elevado de subdominios no intersectantes entre s
denominados elementos finitos. Dentro de cada elemento se distinguen una serie de puntos
representativos llamados nodos. Dos nodos son adyacentes si pertenecen al mismo elemento.
( )
. Adems de la ecuacin diferencial se
. Estas condiciones pueden ser:
La solucin obtenida para el sistema es

deben tener condiciones de contorno
Condicin de contorno de Dirichlet, especifica el valor de la solucin en los puntos del

contorno del dominio.
(9.2)
Condicin de contorno de Neumann, especifica el valor de la derivada de la solucin

en el contorno del dominio.
(9.3)
Las condiciones de contorno del problema completo son una combinacin de los dos tipos
anteriores.
(9.4)
La definicin del problema es lo que se llama la forma fuerte del problema, esto incluye la
ecuacin diferencial y las condiciones de contorno. Hasta este punto no se ha hecho ninguna
discretizacin ni ninguna aproximacin.
9.2.
Mtodo de Rayleigh-Ritz y mtodo de Galerkin
El objetivo del mtodo es resolver la ecuacin diferencial definida en la ecuacin (3.1). Una
forma de resolver la ecuacin bajando un orden a la ecuacin diferencial es integrando la
funcin en todo el dominio. Si la funcin es cero en todo el dominio entonces la integral debe
ser cero.
Pero esto no asegura que
(9.5)
, para ello se introduce una funcin de peso ( ).

( )
- 96 -
( )
(9.6)
Mtodos numricos
A parte de transformar la ecuacin diferencial se deben tambin transformar las condiciones

de contorno.
( )(
( )(
(9.7)
El mtodo integral consiste en introducir una aproximacin de en cada nodo.
( )
( )
( )(
( )
(9.8)
Con esta ecuacin se obtiene la solucin del mtodo de Rayleigh-Ritz. En general este mtodo
no se usa mucho.
El mtodo de Galerkin utiliza la siguiente aproximacin para la funcin.
Siendo una combinacin lineal de

es un sistema de ecuaciones lineales.
( )
(9.9)
. Si adems la ecuacin integral es lineal, lo que queda
El problema con este mtodo es que en general estas funciones estn definidas en todo el
dominio y es muy complicado concentrar la combinacin de
que cumplan todas las
condiciones de contorno.
9.3.
Ejemplo de formulacin fuerte para problema estructural
Un ejemplo clsico de aplicacin del mtodo de elementos finitos es en problemas

estructurales. Se desarrolla a modo de ejemplo en este apartado la formulacin dbil de un
problema estructural de vigas.
En una viga se pueden tener tres tipos de cargas: cargas concentradas, cargas distribuidas y
momentos. Aislando una porcin de la viga se obtienen las ecuaciones diferenciales para los
distintos esfuerzos. Se denomina al esfuerzo cortante vertical y al momento flector.
Carga concentrada
Figura 9.1. Carga concentrada.

(9.10)
- 97 -
Mtodos numricos
Carga distribuida

( )
( )
(9.11)
Carga concentrada

(9.12)
Se estudia el problema de flexin en la viga. Siendo
elemento de la viga se tiene:
la inversa del radio de curvatura
( )
( )
del
(9.13)
Siendo la direccin de la fibra neutra el ngulo de curvatura. La derivada del ngulo se

puede aproximar y dejarlo en funcin del desplazamiento vertical .
( )
(9.14)
Tambin se puede relacionar el momento flector con el desplazamiento vertical:

( )
(9.15)
Se reescribe la ecuacin anterior utilizando las ecuaciones diferenciales obtenidas para el caso
de carga distribuida (ecuacin (9.11)).
(
- 98 -
( )
(9.16)
Mtodos numricos
Se le tienen que aadir las condiciones de frontera para terminar de definir la forma fuerte del
problema. Las condiciones de contorno pueden ser:
Desplazamiento vertical
( )
Rotacin
( )
(9.18)
Cortante
( )
)
(9.17)
(9.19)
Momento
( )
(9.20)
Para este ejemplo se consideran las siguientes condiciones de frontera:

( )
( )
()
)
()
(9.21)
Se empieza ahora definiendo la forma dbil del problema. Se utiliza la ecuacin integral
definida en la ecuacin (9.6). En este problema se podra considerar que la funcin es el
desplazamiento virtual.
(9.22)
Se integra la parte de la izquierda por partes.
( )
)]
( )
)
(9.23)
La parte de la izquierda est definido para los dos extremos de la barra introduciendo ah las
condiciones de contorno, en este caso es el cortante.
( )
)
()
(9.24)
Se vuelve a integrar por partes.
( )
)
( )
]
- 99 -
( )
(9.25)
Mtodos numricos
En este caso la condicin de contorno que se aplica es el momento.

( )
()
()
(9.26)
Para que se cumpla la ecuacin anterior se ha impuesto que:

( )
( )
(9.27)
Adems para que la integral de la izquierda se pueda integrar el desplazamiento virtual debe
tener segunda derivada.
9.4.
Funciones de forma
Para resolver la ecuacin diferencial utilizando MEF se debe crear un dominio de elementos
finitos. ste se compone de elementos y nodos. Los elementos pueden tener mltiples
formas, aunque se suelen emplear elementos triangulares o cuadrilteros (en el caso 2D).
Tambin se necesita una forma de caracterizar las propiedades fsicas de los elementos. Los
vnculos entre los nodos de un elemento se caracterizan por las funciones de forma.
La funcin de forma
asociada al nodo y el elemento debe satisfacer que sea la unidad en
el nodo y cero en los dems.

(9.28)
Por ejemplo, considerando una viga, la distribucin de los desplazamientos a lo largo del
elemento (con un nodo en cada extremo) sera:
{
}{
(9.29)
Siendo
y
los desplazamientos en los nodos. Las funciones de forma en este caso seran
rectas que deben satisfacer la ecuacin (9.28).
(9.30)
Figura 9.4. Funciones de forma para un elemento de una dimensin.

Una vez obtenida la distribucin de las funciones ya se puede integrar. Introduciendo las
funciones de forma que suelen ser lineales se pueden integrar fcilmente las expresiones
obtenidas en la forma dbil.
- 100 -
9.5.
Mtodos numricos
Cuadratura de Gauss
En general no es necesario integrar analticamente todas las expresiones de la forma dbil una
vez introducidas las funciones de forma. Se puede, por ejemplo, utilizar la cuadratura de gauss
para obtener el resultado numrico de la integral.
A diferencia de otros mtodos de integracin numrica, los puntos de evaluacin de la funcin
estn definidos. El resultado obtenido en la cuadratura de Gauss de puntos es el de integrar
].
un polinomio de orden
o menos. El dominio de la cuadratura por regla es de [
( )
( )
(9.31)
Donde
es el peso para el punto de integracin .
En la siguiente tabla se pueden ver una lista de puntos de integracin y de pesos para los tres
primeros valores de .
Nm. de puntos
Puntos de integracin
Pesos
Tabla 9.1. Puntos de integracin y pesos.

Como normalmente las funciones de formas son lineales, se suelen tener que integrar
polinomios, obteniendo resultados exactos con la cuadratura de Gauss.
9.6.
Tipos de elementos en 2D
En el apartado 9.5 se puede ver un elemento para el caso unidimensional con dos nodos y sus
funciones de forma. Los siguientes elementos son los que ms se utilizan en el caso
bidimensional.
Las funciones de forma se definen en coordenadas locales y .
Elementos triangulares
Los elementos triangulares ms bsicos se componen de tres nodos en los vrtices del
elemento. Se utilizan coordenadas locales para para obtener las funciones de forma.
Para pasar de unas coordenadas a otras se utiliza el siguiente cambio:
{ }
]{ }
- 101 -
(9.32)
Mtodos numricos
( )
( )
( )
Figura 9.5. Transformacin entre coordenadas locales y coordenadas globales.

El rea del elemento es:
(
)(
)(
(9.33)
La funcin inversa es:

[
{ }
]{ }
}
)
(9.34)
Las funciones de forma en coordenadas locales son:

(9.35)
(9.36)
(9.37)
Las tres funciones de forma suman la unidad. Las derivadas de las funciones de forma respecto
a las dos variables son:
(9.38)
(9.39)
(9.40)
Utilizando la transformacin las funciones de forma en las coordenadas globales queda:
(
[(
) ]
(9.41)
[(
) ]
(9.42)
[(
) ]
(9.43)
- 102 -
Mtodos numricos
(9.44)
(9.45)
(9.46)
Elementos cuadrilteros
Los elementos cuadrilteros ms bsicos se componen de cuatro nodos en los vrtices del
elemento.
Figura 9.6. Transformacin de coordenadas de un elemento rectangular.

Las funciones de formas para este elemento genrico son:
)(
(9.47)
)(
(9.48)
)(
(9.49)
)(
(9.50)
Se cumple que la suma de todas las funciones es igual a la unidad. Las derivadas de estos
elementos respecto a las diferentes variables son:
(9.51)
(9.52)
- 103 -
(9.53)
(9.54)
Mtodos numricos
La matriz de derivadas de las funciones de forma es

4
(9.55)
[
Para pasar de las coordenadas locales a las globales se utiliza el Jacobino.
(9.56)
Donde ste se calcula como:

(9.57)
Donde
es la posicin en donde se quiere evaluar el Jacobino.
Tambin existen otros tipos de elementos cuadrilteros utilizando ms nodos. El

procedimiento de obtencin de las funciones de forma y sus derivadas es igual que en el caso
de tener solo cuatro nodos.
Elemento cuadriltero de
elementos
Se pueden aumentar el orden de los elementos introduciendo ms nodos por elemento.
Figura 9.7. Elemento rectangular con
nodos.
Se han introducido nueve nodos en el nodo. Las funciones de forma son por lo tanto ms
complicadas. La funcin de forma del nodo debe anularse en los nuevos puntos, por ejemplo
).
en el punto (
(
(9.58)
Se tienen tres tipos diferentes de nodos en este elemento, se tienen: nodos de las esquinas
que tienen funciones de forma similares a la mostrada para , nodos laterales y el nodo
central.
(
)(
(
)
)(
- 104 -
)
)
(9.59)
(9.60)
Mtodos numricos
Elemento cuadriltero de
nodos Serendipity
Eliminando el nodo central se obtiene un elemento de nodos que tiene las ventajas de
reducir el orden de las funciones de forma. En este caso se tienen dos tipos de nodos: los de
las esquinas y los de los laterales.
(
)(
)(
)(
(9.61)
(9.62)
A parte de eliminar un grado de la ecuacin (eliminando el nodo central) los elementos del
lateral son ms simples (pierden los trminos de orden
).
9.7.
Ejemplo de problema trmico
El ejemplo que se desarrolla aqu es un problema trmico con radiacin. En este apartado se
desarrolla el ejemplo y el programa descrito en este tema es el que resuelve este ejemplo.
La siguiente figura muestra la seccin de un radiador para uso en el espacio profundo. Debido
a su doble simetra solo se muestra una cuarta parte de la seccin.
( )
Figura 9.8. Seccin del radiador espacial.
La carga de pago del radiador situada en la zona central debe mantenerse a
conocida. El
radiador acta como un cuerpo negro segn la ley de Stefan-Boltzmann. La temperatura
ambiente equivalente es tan baja que se puede despreciar.
Para este ejemplo se utilizar como connotacin de matrices las letras sin cursiva y en negrita.
Forma dbil
La ecuacin que gobierna la distribucin de temperaturas es la ley de Fourier.

(9.63)
Donde es el flujo de calor por unidad de longitud,
gradiente local de temperaturas.
- 105 -
es la conductividad trmica y
es el
Mtodos numricos
Debido a la falta de fuentes de calor y que el problema es estacionario, la ley de Fourier se

simplifica a la ecuacin de Laplace.
(9.64)
Se tienen dos tipos de condiciones de contorno. La condicin de contorno de Dirichlet est
presente en el centro donde la temperatura
es conocida. La condicin de contorno de
Neumann est en la pared exterior del radiador, siendo el flujo de calor de radiacin.
4
(9.65)
Es recomendable adimensionar el problema para simplificar el problema y reducir las

dependencias. Se define la temperatura de referencia como la temperatura de la carga de
pago y la longitud de referencia como . La ecuacin de Laplace adimensionalizada queda:
(9.66)
Las condiciones de contorno quedan:
4)
(9.67)
El trmino constante en la condicin de contorno de Neumann puede expresarse como un

coeficiente .
(9.68)
Este parmetro es una relacin entre el flujo de calor a travs del radiador y el calor de
radiacin que se puede emitir, siempre que la diferencia de temperaturas entre el interior y la
superficie como la temperatura superficial son del mismo orden.
(9.69)
La potencial adimensional del radiador se puede definir como:
(9.70)
Se pueden obtener analticamente los valores de la potencia para los casos extremos. Si
la conductividad es muy baja y el radiador se comporta como un aislante, por lo tanto la
temperatura de la superficie exterior es muy baja y la potencia emitida muy baja tambin
(
). Si en cambio la temperatura en todo el radiador es casi igual a la temperatura
de la carga de pago. En un cuarto de la seccin la potencia radiada sera:
- 106 -
(9.71)
Mtodos numricos
Por lo tanto el orden de magnitud de la potencia adimensional es (
) para
A partir de este momento todas las variables que se utilicen son adimensionales por lo que la
notacin con acento circunflejo ya no se utiliza. Se tienen que tener en cuenta las siguientes
expresiones:
-
Regla de la derivada de un producto

(
( )
(9.72)
Teorema de la divergencia
(9.73)
La forma dbil se obtiene integrando la ecuacin de Laplace multiplicada por una funcin
arbitraria .
(9.74)
Se integra esta expresin por partes:
(9.75)
La integral de lnea se hace donde se tienen condiciones de contorno (

una funcin tal que en la condicin de contorno de Dirichlet sea cero.
(
). Se elige
()
(9.76)
Siendo la forma dbil del problema:
( )
(9.77)
( )
(9.78)
Discretizacin
La temperatura ( ) se interpola a partir de las temperaturas

funciones de forma ( ) para cada nodo contenido en el elemento.
Se utilizan elementos cuadrilteros. La temperatura
puede escribirse como:
( )
( )
( )
( )
( ) de un punto dentro de un elemento
4(
)]
( )
[ 4]
- 107 -
las correspondientes
(9.79)
Mtodos numricos
El gradiente de temperatura es:

4
(9.80)
[
] [ 4]
Se utilizan las mismas funciones de forma para interpolar la funcin de peso

( )
( )
( )
( )
del elemento.
(9.81)
Aplicando la ecuacin (9.77) a cada elemento se obtiene:
(9.82)
Se introducen las expresiones que contienen las funciones de forma.
(9.83)
Y sta se puede reescribir como:

(9.84)
Donde:
(9.85)
)
(9.86)
Ensamblaje
El sistema global se obtiene aadiendo la contribucin de cada elemento.
(9.87)
Esto se debe hacer usando la numeracin global de nodos y elementos. La ecuacin queda:
(9.88)
Esta ecuacin debe cumplirse para cualquier
cualquier .
que es lo mismo que decir que se cumple para
(9.89)
Debido a la no linealidad del problema (causada por el flujo de radiacin) el sistema se tiene
que resolver de forma iterativa.
- 108 -
Mtodos numricos
El calor de radiacin se linealiza de la siguiente forma:

| (
El vector
(9.90)
puede reescribirse como:

(9.91)
El subndice indica que est evaluado con las temperaturas de la iteracin anterior. La
ecuacin (9.89) se escribe finalmente como un sistema lineal.
(
Donde
(9.92)
deben ser evaluadas para cada iteracin.
Integracin
Los elementos que se usan son cuadrilteros de cuatro nodos. Las integrales de volumen son
del orden
(de segundo orden) y de rea ( dimensiones) por lo que se necesitan cuatro
puntos de integracin para la cuadratura de Gauss, dos en cada dimensin.
: I
Figura 9.9. Elemento cuadriltero de nodos en coordenadas locales (izq.) y globales (der.).
La integral de la ecuacin (9.85) se calcula de la siguiente forma:
4
||
Donde
es el peso (siendo igual a en todos los casos). El Jacobino
forma derivadas en un cierto punto se obtiene como:
|)
(9.93)
y las funciones de
(9.94)
El flujo de calor se considera lineal en el elemento y puede integrarse fcilmente

(analticamente) en el contorno de Neumann. La integral en un lado del elemento (de longitud
) es:
(9.95)
- 109 -
Mtodos numricos
Utilizando las funciones de forma en una dimensin de la ecuacin (9.30). Se linealiza ahora
esta ecuacin.
|
]
4
(
[
)
]
[ ]
(9.96)
Potencia del radiada
Una vez calculada la distribucin de temperaturas en todo el dominio se puede calcular la

potencia del radiador. Se calcula como la integral de todo el flujo de calor en el contorno de
Neumann.
Para un elemento la potencia adimensional se calcula utilizando un nico punto de integracin
de Gauss ya que es del orden de .
4)
Para obtener la potencia total se suman las contribuciones de todos los elementos.
- 110 -
(9.97)
9.8.
Mtodos numricos
Programa
Programa 7. Radiador espacial

Se presenta ahora el cdigo que resuelve el ejemplo descrito en la seccin 9.7. Para poder
visualizar la solucin, el siguiente cdigo est adaptado para que la distribucin de
temperaturas la lea un programa llamado GID de la empresa CIMNE La versin gratuita del
programa se puede descargar desde la pgina de la empresa. Tiene limitados el nmero de
nodos que se pueden utilizar pero para este ejemplo es suficiente.
Al programa se le debe introducir la malla (con los elementos y los nodos) y los contornos con
condiciones de contorno, incluida en el apndice de este libro, seccin 10.8.
El programa se estructura mediante un mdulo que incluye todas las variables y subrutinas. El
programa principal solo tiene las variables que se pueden configurar y se dedica a ir llamando
a las distintas subrutinas para que vayan haciendo el clculo.
El error es la diferencia mxima entre temperaturas de iteraciones consecutivas. La secuencia
del programa es:
-
Cargar la malla del archivo imput_mesh.txt

Inicializar las variables, crear las coordenadas locales de los elementos cuadrilteros y
las matrices de las funciones de forma y de sus derivadas
Se ensambla la matriz , sta es la que no cambia entre iteraciones
El solver es la subrutina que tiene el bucle iterativo que va calculando las nuevas
temperaturas y con esas las matrices
y y resuelve el sistema lineal.
Una vez se tiene la distribucin de temperaturas se calcula la potencia radiada
Las dos ltimas dos subrutinas sirven para escribir los archivos necesarios para que los
pueda leer el programa GID.
program spaceRadiator
use subroutines
implicit none
integer i
!Program configurator
alpha
= 100.
maxIterations = 30
error
= 0.0001
!Program sequence
call readMesh();
print*, "Read Mesh Done!"
call init();
print*, "Init
Done!"
call assembleK();
print*, "Assemble K Done!"; print*," "
call solver();
print*, "Solver Done!"
call getW();
Print*, "Get W Done!"
call writeGidMesh();
call writeTemperature();
end program spaceRadiator
- 111 -
Mtodos numricos
El mdulo subroutines incluye todas las variables y subrutinas. Las variables se utilizan de
forma global, es decir que cada subrutina puede cambiar sus valores.
module subroutines
implicit none
!Variables: Local means element coordinates. X: coordinates of node;
!N: shape function; DN: deriv.N; IP: Integ. points
real, save
:: localX(4,2), localN(4,4), localDN(4,2,4), localIP(4,2), alpha
real, allocatable, save :: node(:,:), K(:,:), T(:), q0(:), T0(:), Kr(:,:), Ktot(:,:), Tit(:,:)
integer, allocatable, save :: elemNode(:,:), boundIn(:), boundExt(:,:)
integer, save
:: nNode, nElem, nIn, nExt, nIP, nX
integer, save
:: maxIterations, endIT
real, save
:: error
contains
La primera subrutina Se encarga de abrir el archivo imput_mesh.txt y obtener los datos del
mallado.
subroutine readMesh()
implicit none
integer i
real aux, aux2
open(UNIT = 5, FILE = 'input_mesh.txt', ACCESS = 'SEQUENTIAL')
!Read nodal coordinates
read(5,*) nNode
allocate (node(nNode,2))
do i = 1, nNode
read(5,*) aux, node(i,:), aux2 !First and last numbers not needed
end do
!Read Elements
read(5,*) nElem
allocate(elemNode(nElem,4))
do i = 1, nElem
read(5,*) aux, elemNode(i,:)
end do
!Read Boundary nodes that Radiate
read(5,*) nExt
allocate(boundExt(nExt,2))
do i = 1, nExt
read(5,*) aux, boundExt(i,:)
end do
- 112 -
Mtodos numricos
!Read Boundary nodes with constant Temperature

read(5,*) nIn
allocate(boundIn(nIn))
do i = 1, nIn
read(5,*) aux, boundIn(i)
end do
close(5)
end subroutine readMesh
La subrutina init() se encarga de inicializar variables y de crear las coordenadas locales de los
elementos y de los puntos de integracin y las matrices de funciones de formas y de sus
derivadas.
subroutine init()
implicit none
real aux
integer i
allocate(K(nNode, nNode), Kr(nNode, nNode), KTot(nNode,nNode), &
T(nNode), T0(nNode), q0(nNode))
allocate(Tit(nNode,maxIterations))
K = 0.; Kr = 0.; KTot = 0.; T = 0.; T0 = 0.; q0 = 0.; nIP = 4; nX = 4; Tit = 0.
!Initial temperature
if (alpha .ge. 1) then
T0 = 0.9
else
T0 = alpha
end if
!Node positions
localX(1,1) = -1.;
localX(2,1) = 1.;
localX(3,1) = 1.;
localX(4,1) = -1.;
localX(node, xi-eta)
localX(1,2) = -1.
localX(2,2) = -1.
localX(3,2) = 1.
localX(4,2) = 1.
!Integration points position localIP(IP, xi-eta)

aux = 1. / sqrt(3.)
localIP = localX * aux
do i = 1, 4
!Shape functions localN(IP, shape function)
localN(i,1) = (1. - localIP(i,1)) * (1. - localIP(i,2))
localN(i,2) = (1. + localIP(i,1)) * (1. - localIP(i,2))
localN(i,3) = (1. + localIP(i,1)) * (1. + localIP(i,2))
localN(i,4) = (1. - localIP(i,1)) * (1. + localIP(i,2))
- 113 -
Mtodos numricos
!Derivative localDN(IP, dxi - deta, shape function)

localDN(i,1,1) = - 1. + localIP(i,2); localDN(i,2,1) = - 1. + localIP(i,1)
localDN(i,1,2) = 1. - localIP(i,2); localDN(i,2,2) = - 1. - localIP(i,1)
localDN(i,1,3) = 1. + localIP(i,2); localDN(i,2,3) = 1. + localIP(i,1)
localDN(i,1,4) = - 1. - localIP(i,2); localDN(i,2,4) = 1. - localIP(i,1)
end do
localDN = 0.25 * localDN; localN = 0.25 * localN
end subroutine init
La subrutina assembleK se encarga de calcular y ensamblar . sta es la matriz de rigidez que

no cambia entre iteraciones. La subrutina calcula las matrices
(ecuacin (9.93)) y luego las
ensambla (en la matriz global) para cada elemento.
Para poder calcular
se debe llamar a la subrutina isoTransform que devuelve la matriz de
derivadas de las funciones de forma y el Jacobiano para cada punto de integracin, utilizando
la ecuacin (9.94).
subroutine isoTransform (x, dN, detJ) !Returns dN and detJ
implicit none
real, intent(in) :: x(nX,2)
real, intent(out) :: dN(nIP,2,nX), detJ(nIP)
integer i
real J(nIP,2,2), invJ(nIP,2,2)
do i = 1, nIP
!Obtain Jacobian and determinant. J = D x
J(i,:,:) = matmul(localDN(i,:,:),x)
detJ(i) = abs(J(i,1,1) * J(i,2,2) - J(i,2,1) * J(i,1,2))
!Obtain the inverse of a 2x2 matrix
invJ(i,1,1) = J(i,2,2); invJ(i,1,2) = -J(i,1,2)
invJ(i,2,1) = -J(i,2,1); invJ(i,2,2) = J(i,1,1)
invJ(i,:,:) = (1. / detJ(i)) * invJ(i,:,:)
!Obtain dN = invJ * localDN
dN(i,:,:) = matmul(invJ(i,:,:), localDN(i,:,:))
end do
end subroutine isoTransform
subroutine assembleK()
implicit none
integer i, j, l, eN(nX) !Remember nX is number of nodes per element
real x(nX,2), dN(nIP,2,nX), detJ(nIP)
real localK(nX,nX)
- 114 -
Mtodos numricos
do i = 1, nElem
!Saves, in eN(4), the number of the nodes in the element
eN = elemNode(i,:)
!Saves, in x(4,2), the positions of the nodes
!in global coordinates of the element
do j = 1, nX
x(j,:) = node(eN(j),:)
end do
localK = 0.
call isoTransform(x, dN, detJ)
!K = sum(|J| Dt D)
do j = 1, nIP
localK = localK + detJ(j) * matmul(transpose(dN(j,:,:)),dN(j,:,:))
end do
!Introduces the values in the global matrix K
do j = 1, nX
do l = 1, nX
K(eN(j), eN(l)) = K(eN(j), eN(l)) + localK(j,l)
end do
end do
end do
end subroutine assembleK
La siguiente subrutina es muy parecida a la subrutina assembleK pero sta se encarga de

ensamblar las matrices
y . stas matrices se deben calcular en cada iteracin.
subroutine assembleQ()
implicit none
integer i, j, k, x(2)
real localQ(2), localT(2), localKr(2,2), L
real aux
!Restarts q0 and Kr
q0 = 0.; Kr = 0.
do i = 1, nExt
!Pointer to node number
x = boundExt(i,:)
!Length
L = (node(x(1),1) - node(x(2),1)) * (node(x(1),1) - node(x(2),1))
L = L + (node(x(1),2) - node(x(2),2)) * (node(x(1),2) - node(x(2),2))
L = sqrt(L)
!Temperatures at the nodes
localT(1) = T0(x(1)); localT(2) = T0(x(2))
- 115 -
Mtodos numricos
!Matrix q0
!Heat on the nodes
localQ(1) = localT(1)*localT(1)*localT(1)*localT(1) + 0.5 * &
localT(2)*localT(2)*localT(2)*localT(2)
aux = L / alpha
localQ = localQ * aux
!Introduce values in global q
q0(x(1)) = q0(x(1)) + localQ(1)
q0(x(2)) = q0(x(2)) + localQ(2)
!Matrix Kr
!Local Kr
aux = 4./6.
localKr(1,1) = 2. * aux * localT(1)*localT(1)*localT(1)
localKr(2,1) = aux * localT(1)*localT(1)*localT(1)
aux = - L / alpha
localKr = localKr * aux
!Introduce values in global Kr
do j = 1, 2
do k = 1, 2
Kr(x(j),x(k)) = Kr(x(j),x(k)) + localKr(j,k)
end do
end do
end do
endsubroutine assembleQ
La subrutina innerBoundary introduce las condiciones de contorno de Dirichlet. Simplemente,

para todos los nodos donde la ecuacin es conocida, borra la ecuacin e introduce una nueva
ecuacin
.
subroutine innerBoundary()
implicit none
integer i, n
do i = 1, nIn
n = boundIn(i)
KTot(n,:) = 0.; KTot(n,n) = 1.
T(n) = 1. !Boundary temperature is 1
end do
end subroutine innerBoundary
- 116 -
Mtodos numricos
La subrutina solveSystem es un simple cdigo de resolucin de sistemas lineales mediante el

mtodo de Gauss. De forma similar a los programas escritos en el tema de resolucin de
sistemas lineales, la matriz de entrada debe estar transpuesta para gestionar de forma ms
eficiente la memoria.
subroutine solveSystem(a, b, n) !Matrix needs to be transposed
implicit none
real :: mult
do pivot = 1, n-1
do row = pivot+1, n
a(pivot+1:n,row) = a(pivot+1:n,row) - mult * &
a(pivot+1:n,pivot)
end do
end do
!Obtain solutions
b(n) = b(n) / a(n,n)
do row=n-1,1,-1
end do
end subroutine
Finalmente la subrutina solver es la que se encarda del bucle iterativo y calcula la distribucin
de las temperaturas en los nodos. Para cada iteracin calcula los vectores
y
llamando a
la subrutina assembleQ. Luego construye un sistema lineal (ecuacin (9.92)) y le introduce las
condiciones de contorno llamando a la subrutina innerBoundary. Finalmente resuelve el
sistema, escribe los resultados y los verifica para saber si el bucle debe finalizarse.
subroutine solver()
implicit none
integer i, j
real a(nNode, nNode)
logical bool
bool = .true.
do i = 1, maxIterations !bucle iterativo
!Obteins matrix Kr and vector q0
call assembleQ();
- 117 -
Mtodos numricos
!Builds linear system Ax=b Where A=KTot and b=T

KTot = K - Kr
T = q0
!Introduces Dirichlett boundary conditions
call innerBoundary()
!Solves system
a = transpose(KTot)
call solveSystem(a, T, nNode)
!Writtes result
Tit(:,i) = T
!End loop
if(maxval(abs(T - T0)).lt. error) then
print*, " "
print*, "Final iteration: ", i
print*, " "
bool = .false.
exit
end if
!New iteration
T0 = T
print*, "Iteration ", i,"Done!"
end do
endIT = i
if (bool) endIT = i - 1
end subroutine
Una vez ya se tiene la distribucin de temperaturas, se puede calcular la potencia

adimensional. Se calcula la potencia radiada en cada elemento (ecuacin (9.97)) y sta se va
sumando a la global.
subroutine getW()
implicit none
real L, W, localW, aux, localT(2)
integer i, x(2)
aux = 0.5
W = 0.
do i = 1, nExt
x = boundExt(i,:)
- 118 -
Mtodos numricos
!Length
L = sqrt(L)
localT(1) = T0(x(1))*T0(x(1))*T0(x(1))*T0(x(1))
localT(2) = T0(x(2))*T0(x(2))*T0(x(2))*T0(x(2))
!Emitted power
localW = L * aux * (localT(1) + localT(2))
!Global power
W = W + localW
end do
print*, " "
print*, "Alpha:", alpha
print*, "Non-dim. power:", W
print*, " "
end subroutine getW
Las siguientes dos subrutinas son una adaptacin de un cdigo para que el GiD pueda leer el
resultado de la distribucin de nodos, elementos y temperaturas.
subroutine writeGidMesh()
implicit none
! x : Nodal Coordinates
! conec : Conectivity (Nodes of elements)
! n_nod : Number of Nodes
! n_el : Number of Elements
integer n_nod, n_el, conec(4,nElem), i
real x(2,nNode)
!Convert the variables to R.F. variables
n_nod = nNode; n_el = nElem
x(1,:) = node(:,1); x(2,:) = node(:,2)
conec = transpose(elemNode)
open(UNIT=6,FILE='radiation_analysis.post.msh',ACCESS='SEQUENTIAL',&
STATUS='REPLACE') ! Create File
write(6,*) '# postprocess mesh for GiD' ! File Header
write(6,*) 'MESH "RADIATION_FEA" dimension 2 ElemType Quadrilateral Nnode 4'
! Write Nodal Coordinates
write(6,*) 'Coordinates'
write(6,*) '# node number coordinate_x coordinate_y'
- 119 -
Mtodos numricos
do i = 1, n_nod
write(6,*) i, x(:, i)
end do ! i
write(6,*) 'end coordinates'
! Write Surface Elements
write(6,*) 'Elements'
write(6,*) '# element node_1 node_2 node_3 node_4'
do i = 1, n_el
write(6,*) i, conec(:, i)
end do ! i
write(6,*) 'end elements'
close(6) ! Close File
end subroutine writeGidMesh
!**************************************************************
subroutine writeTemperature()
implicit none
integer n_nod, n_ite
real temperature(nNode, endIT)
integer nodeF, iter
character*(*) temp_h, scalar, endvalues, values
character*(*) header, filename
parameter (temp_h = 'Result "TEMPERATURE" "ITERATION=" ')
parameter (scalar = ' Scalar OnNodes')
parameter (endvalues = 'End Values', values = 'Values')
parameter (header = 'GiD Post Results File 1.0')
parameter (filename = 'radiation_analysis.post.res')
n_nod = nNode; n_ite = endIT; temperature(:,:) = Tit(:,1:endIT)
10
20
! Format specs
format (A) ! Single character field
format (A, I0, A) ! Use to write iteration number
! Open Output File & Overwrite
open(UNIT=6, FILE=filename, ACCESS='SEQUENTIAL', &
STATUS='REPLACE')
! Write Header
write(6,10) header
! Write Temperature Distribution for Each Iteration
do iter = 1, n_ite
write(6,20) temp_h, iter, scalar
write(6,10) values
- 120 -
Mtodos numricos
do nodeF = 1, n_nod
write(6,*) nodeF, temperature(nodeF, iter)
end do ! nodeF
write(6,10) endvalues
end do ! iter
! Close file
close(6)
end subroutine writeTemperature
end module subroutines
Los siguientes resultados corresponden a las temperaturas adimensionales en un cuarto de

radiador con
. El radiador se ha mallado con 288 nodos. El programa finaliza cuando el
error es menor que .
.
Las primeras dos soluciones mostradas en las siguientes figuras corresponden para valores de
muy pequeo y muy grande.
Figura 9.10. Temperaturas adimensionales para
Figura 9.11.Temperaturas adimensionales para
La Figura 9.10 muestra el resultado cuando la conductividad es muy baja. Como ya se supona,
la temperatura en el interior es alta mientras que en el exterior la temperatura es muy baja.
Como caso opuesto, la Figura 9.11 muestra el resultado cuando la conductividad es muy alta.
La temperatura en todo el dominio es muy alta.
Los valores de la potencia adimensional
ver en la Tabla 9.2 y en la Figura 9.12.
para distintos valores del parmetro
- 121 -
se pueden
.
.
.
Mtodos numricos
Tabla 9.2. Potencia adimensional
para distintos valores de .
12
10
8
6
4
2
0
1.E-03
1.E-02
1.E-01
1.E+00
1.E+01
1.E+02
1.E+03
1.E+04
1.E+05
Figura 9.12. Potencia adimensional
para distintos valores de .
Como se haba predicho en el tema 9.7, cuando la conductividad es muy baja (

) la
potencia adimensional tiende a ser muy baja tambin (del orden de magnitud de ). Mientras
)
que si la conductividad es alta ( ) la solucin converge hacia (
.
- 122 -
Mtodos numricos
10. Apndice
10.1. Programacin en Fortran
Programa 1. Mnimo error de un tipo de variable
program program1
implicit none
real small = 1.
integer i
do i = 1, 1000
if (1. + small .gt. 1.) then
small = 0.5 * small
else
exit
end if
end do
small = 2. * small
print*, small
print*, epsilon(small)
end program
- 123 -
Mtodos numricos
Programa 2. Clculo del nmero

program program2
implicit none
real*8 x, y
integer*8 total, inside
total = 0
inside = 0
10
continue
!Ball thrown
call random_number(x)
call random_number(y)
total = total + 1
!Looks where the ball fell
if(x*x + y*y .lt. 1.) inside = inside + 1
!Shows the result every 1000 iterations
if (mod(total, 1000) .eq. 0) then
print*, total, 4. * dble(inside) / dble(total)
end if
go to 10
end program
- 124 -
Mtodos numricos
10.2. Interpolacin
Programa 3. Entrada de datos e interpolacin
program program3
implicit none
real, allocatable :: ydy(:,:), x(:)
real xInt, yInt, step
integer n, i, nExit, last
!Reading Data
open(unit = 1, file='initialData', access='SEQUENTIAL')
read(1,*) n
allocate(ydy(2,n), x(n))
do i = 1, n
read(1,*) x(i), ydy(1,i)
end do
close(1)
!Obtaining Slopes
ydy(2,1) = (ydy(1,2) - ydy(1,1)) / (x(2) - x(1))
do i = 2, n - 1
ydy(2,i) = (ydy(1, i+1) - ydy (1, i-1)) / (x(i+1) - x(i-1))
end do
ydy(2,n) = (ydy(1,n) - ydy(1,n-1)) / (x(n) - x(n-1))
print *, 'Introduce number of points:'
read(*,*) nExit
xInt = x(1)
step = (x(n) - x(1)) / real(nExit - 1)
open(unit=2, file='dataExit', access='SEQUENTIAL', status='REPLACE')
last = 1
do i = 1, nExit
!Find interval
do while (xInt .gt. x(last+1))
last = last + 1
end do
!Obtain results
call hermite(ydy(:,last:last+1), x(last:last+1), xInt, yInt)
write(2,*) xInt, yInt
!New step
xInt = xInt + step
xInt = min(xInt, x(n))
end do
close(2)
end program
- 125 -
Mtodos numricos
!***************************************************
subroutine hermite (v1, v2, x, yx)
implicit none
real, intent(in) :: v1(4), v2(2), x
real, intent(out) :: yx
real :: chi, span
span =v2(2) - v2(1)
chi = (x - v2(1)) / span
yx = v1(1) * (1. + 2. * chi) * (1. - chi) * (1. - chi) + &
v1(2) * span * chi * (1. - chi) * (1. - chi) + &
v1(3) * chi * chi * (3. - 2. * chi) + &
v1(4) * span * chi * chi * (chi - 1.)
end subroutine
- 126 -
Mtodos numricos
10.3. Integracin
Programa 4. Obtencin de la serie de Fourier
program program4
implicit none
integer i
real y(n), step, x, modes(2, 0:8)
x = -pi
step = 2. * pi / (real(n) - 1.)
!Discretization
do i = 1,n
y(i) = 0.5 + 3. * cos(2. * x + 0.75) + 1. * cos(6. * x + 0.25)
x = x + step
end do
call fourier (y, modes, n, 8)
!Print results
do i = 0, 8
print* , modes(1,i), modes(2,i)
end do
end program
!***************************************************
subroutine trapice(y, b, z, n)
implicit none
real, intent (in) :: y(n), b
real, intent (out) :: z
z = 0.5 * (y(1) + y(n))+ sum(y(2:n-1))
z = z * b / (real(n) - 1.)
end subroutine
!***************************************************
subroutine fourier (y, modes, n, m)
implicit none
integer, intent (in) :: n, m
real, intent (in) :: y(n)
real, intent (out) :: modes(2, 0:m)
integer i
real z(n), x(n), dx, invPi, a, b
- 127 -
Mtodos numricos

invPi = 1. / pi
dx = 2. * pi / (real(n) - 1.)
x(1) = -pi
do i = 2, n
x(i) = x(i-1) + dx
end do
!First coeficient
call trapice(y, 2.*pi, a, n)
modes(1,0) = a * 0.5 * invPi
do i = 1, m
!Cos coeficients
z = y * cos(real(i) * x)
call trapice(z, 2.*pi, a, n)
a = a * invPi
!Sin coeficients
z = y * sin(real(i) * x)
call trapice(z, 2.*pi, b, n)
b = b * invPi
modes(2,i) = -atan(b / a)
modes(1,i) = sqrt(a*a + b*b)
end do
end subroutine
- 128 -
Mtodos numricos
Programa 5. Iteraciones y extrapolacin

program program5
implicit none
integer :: i, j, n
real*8, parameter :: a = 0., b = 1.
real*8 suma, prevInteg, integ, h, sumEnds, aux, x, analitical
n = 10
h = (b - a) / dble(n)
suma = 0.
!Sum of limits divided by two
call evaluateFunction(a, aux)
sumEnds = aux
call evaluateFunction(b, aux)
sumEnds = (sumEnds + aux) * 0.5
do i = 1, 10
!Sum of the values of the function
if(i .eq. 1) then
x=a+h
do j = 1, (n - 1)
suma = suma + aux
x=x+h
end do
else
x=a+h
do j = 1, (n - 1), 2
suma = suma + aux
x=x+2*h
end do
end if
!Integral
integ = h * (sumEnds + suma)
!Number of intervals and size of interval
n=2*n
h = h * 0.5
!Richardson extrapolation
if(i .eq. 1) then
print*,"No extrapolation", " With extrapolation"
analitical = .2 * dsin(dble(5.)) - 1.
else
aux = (4. * integ - prevInteg) / 3.
print*, integ - analitical, aux - analitical
end if
prevInteg = integ
end do
end program
- 129 -
Mtodos numricos
!***************************************************
subroutine evaluateFunction(x, y)
implicit none
real* 8, intent(in) :: x
real* 8, intent(out) :: y
y = dcos(5. * x) + 3. * x * x
end subroutine
- 130 -
Mtodos numricos
10.4. Resolucin numrica de ecuaciones no lineales

Programa 6. Deflexin de un cable
program Program6
implicit none
integer i, j, n
real x1, x2, x3, fx1, fx2, slope
x1 = (2. * k)**(1./3.)
x2 = 1.1 * x1
fx1 = k + sin(x1) - tan(x1)
print*, 'x= ', x1, 'f(x) = ', fx1
do i = 1, itMax
if (x1.eq.x2) exit
fx2 = k + sin(x2) - tan (x2)
print*, 'x = ', x2, 'f(x) = ',fx2
slope = (fx2 - fx1) / (x2 - x1)
x1 = x2
x2 = x3
fx1 = fx2
end do
end program
- 131 -
Mtodos numricos
Programa 7. Resolucin mediante Newton-Raphson

program Program7
implicit none
integer i, j, n
real x1, x2, fx1, slope, cosx, sinx
x1 = (2. * k)**(1./3.)
do i = 1, itMax
cosx = cos(x1)
sinx = sin(x1)
fx1 = k + sinx - sinx / cosx
slope = cosx - 1. / (cosx * cosx)
print*, 'x = ', x1, 'f(x) = ', fx1
if (fx1 .eq. 0) exit
x1 = x2
end do
end program
- 132 -
Mtodos numricos
10.5. Resolucin numrica de ecuaciones lineales

Programa 8. Resolucin de un sistema mediante Gauss
program program8
implicit none
integer i, j
!Initialize matrix and vector
do i = 1, n
do j = 1, n
a(i,j) = 0.5 - rand
end do
a(i,i) = (1. + rand) * real(n)
b(i) = rand
end do
!Solve system
x=b
call solver(aTrans, x, n)
!Errors
print *, 'If the code is correct this is a small number: ', maxval(abs(x))
end program
!****************************************************************************
subroutine solver(a, b, n)
implicit none
real :: mult
do pivot = 1, n-1
do row = pivot+1, n
a(pivot+1:n,row) = a(pivot+1:n,row) - mult &
* a(pivot+1:n,pivot)
end do
end do
!Obtain solutions
b(n) = b(n) / a(n,n)
do row=n-1,1,-1
end do
end subroutine
- 133 -
Mtodos numricos
Programa 9. Sistema con matriz mal condicionada

program program9
implicit none
integer i, j
real :: a(size,size), aTrans(size,size), b(size), x(size), rand
!Generate matrix
do i = 1, size
do j = 1, size
a(i,j) = 0.5 - rand !Number between -0.5 and 0.5
end do
a(i,i) = rand * 1.E-5
!Very small number for the diagonal
b(i) = rand
!Number between 0. and 1.
end do
!Solve system
x=b
call solveMatrix(aTrans, x, size)
!Check results
end program
!****************************************************************************
subroutine solveMatrix(a, b, n)
implicit none
integer :: row, pivot, point(n), i, posRow, posPiv
real :: mult, x(n)
!Initialize pointer vector
do row = 1,n
point(row) = row
end do
do pivot = 1, n-1
!Organize matrix
mult = 0.
do row = pivot, n !Searches biggest number under Pivot
if (abs(a(pivot,point(row))) .GT. mult) then
i = row
mult = abs(a(pivot,point(row)))
end if
end do
- 134 -
Mtodos numricos
row = point(pivot)
point(pivot) = point(i)
point(i) = row
posPiv = point(pivot)
!Make zeros under Pivot
do row = pivot+1, n
posRow = point(row)
mult = a(pivot, posRow) / a(pivot,posPiv)
a(pivot+1:n,posRow) = a(pivot+1:n,posRow) - mult &
* a(pivot+1:n,posPiv)
b(posRow) = b(posRow) - mult * b(posPiv)
end do
end do
!Obtain Results
x(n) = b(point(n)) / a(n,point(n))
do row = n-1,1,-1
posRow = point(row)
x(row) = b(posRow) - &
dot_product(a(row+1:n,posRow), x(row+1:n))
x(row) = x(row) / a(row,posRow)
end do
b=x
end subroutine
- 135 -
Mtodos numricos
Programa 10. Doolittle

program program10
implicit none
integer i, j
!Generate matrix
do i = 1, n
do j = 1, n
end do
a(i,i) = 0.1 * (1. + rand) * real(n) ! Good matrix
end do
!Solve system
x=b
call luDecomposition(aTrans, n)
call luSustitution(aTrans, x, n)
!Check results
end program
!****************************************************************************
subroutine luDecomposition(a, n)
implicit none
real :: mult
do pivot = 1, n-1
do row = pivot+1, n
a(pivot+1:n,row) = a(pivot+1:n,row) &
- mult * a(pivot+1:n,pivot)
a(pivot,row) = mult
end do
end do
end subroutine
!****************************************************************************
- 136 -
Mtodos numricos
subroutine luSustitution(a, b, n)
implicit none
integer :: row, i
!Ly = b
do row = 1, n
b(row) = b(row) - dot_product(a(1:row-1,row),b(1:row-1))
end do
!Ux = y
do row = n, 1, -1
b(row) = b(row) - dot_product(a(row+1:n,row),b(row+1:n))
end do
end subroutine
- 137 -
Mtodos numricos
Programa 11. Crout

program program11
implicit none
integer i, j
real :: a(size,size), aCopy(size,size), b(size), x(size), rand
do i = 1, size
do j = 1, size
end do
a(i,i) = 0.1 * (1. + rand) * real(size) ! Good matrix
end do
aCopy = a
x=b
call croutDescomp(aCopy,size)
call croutSust(aCopy, x, size)
end program
!****************************************************************************
subroutine croutDescomp(a, n)
implicit none
integer :: row, column, i
do i = 1, n
!Obtain L
do row = i, n
a(row,i) = a(row,i) - dot_product(a(row,1:i-1),a(1:i-1,i))
end do
!Obtain U
do column = i + 1, n
a(i, column) = a(i, column) - &
dot_product(a(i,1:i-1),a(1:i-1,column))
a(i, column) = a(i, column) / a(i,i)
end do
end do
end subroutine
!****************************************************************************
- 138 -
Mtodos numricos
subroutine croutSust(a, b, n)
implicit none
integer :: row, i
!Ly = b
do row = 1, n
b(row) = b(row) - dot_product(a(row,1:row-1), b(1:row-1))
end do
!Ux = y
do row = n, 1, -1
b(row) = b(row) - dot_product(a(row,row+1:n),b(row+1:n))
end do
end subroutine
- 139 -
Mtodos numricos
Programa 12. Matriz Banda

Program program12
implicit none
integer, parameter :: size = 50, d = 5
integer i, j, left, right
real :: a(-d:d,size), aCopy(-d:d,size), b(size), bCopy(size), x(size), rand
do i = 1, size
do j = -d, d
a(j,i) = 0.5 - rand !A number between -0.5 and 0.5
end do
a(0,i) = (1. + rand) * real(size) !Good matrix
b(i) = rand !A number between 0. and 1.
end do
aCopy = a
x=b
!Solve
call gaussBand(aCopy, b, d, size)
!Check results
bCopy = b
do i = 1, size
left = min(d, i - 1)
right = min(d, size - i)
x(i) = dot_product(a(-left:right, i),bCopy(i-left:i+right)) - x(i)
end do
end program
!****************************************************************************
implicit none
real, intent(inout) :: a(-d:d,n), b(n)
real mult
!Triangulate matrix
do pivot = 1, n - 1
disp = row - pivot
!Gauss
mult * a(1:d,pivot)
end do
end do
- 140 -
Mtodos numricos
!Solve x
do row = n, 1, -1
end do
end subroutine
- 141 -
Mtodos numricos
10.6. Mtodo de diferencias finitas

Programa 13. Ejemplo de problema mecnico
program finiteDifferences
implicit none
integer n, i, j, maxIt, maxLoop, kas
real*8, allocatable :: K(:,:), R(:), x(:)
real*8 v, v1, h, tref, ka, error
!Program configuration
ka
= 0.5
!Constant in drag
n
= 1000 !Initial number of nodes
maxLoop = 10
!Maximum number of times the program is runned
maxIt
= 100 !Maximum iteration in Newton's method
error
= 0.00001 !Maximum Error
tref = 6.371E6 * 6.371E6 * 6.371E6 / 3.986E14
tref = tref ** 0.5
!Loop for number of nodes
do j = 1, maxLoop
allocate (K(3,n), R(n), x(n))
!Initial values for x
h = (1020. / tref) / dble(n - 1)
call initialValues(x, n, tref, h)
v = 0.
!Loop for number of iterations
do i = 1, maxIt
!Generate matrix K and vector R
call writeSystem (K, R, x, n, tref, h, ka)
!Solve Kdx = -R
R=-R
call gaussBand(K, R, 1, n)
!Solve x1 = x0 + dx
x=x+R
!Initial velocity
v1 = v
v = (4. * x(2) - 3. * x(1) - x(3)) / (2. * h)
!Print results
if(maxval(abs(R)) .lt. error) then
print*, "Error in R:
", maxval(abs(R))
print*, "Iterations needed: ", i
print*, "Initial velocity: ", "
", v
print*, " "
exit
- 142 -
Mtodos numricos
elseif (i .eq. maxIt) then

print*, "No solution found. "
print*, " "
end if
end do
!Renew discretization
deallocate(K, R, x)
n = 1000 + n
end do
end program
!******************************************************************
subroutine writeSystem(K, R, x, n, tref, h, ka)
implicit none
real*8, intent (in) :: x(n), tref, h, ka
real*8, intent (out) :: K(3,n), R(n)
integer i
real*8 h2
h2 = 1. / (h * h)
!Write matrix K
K(2,1) = 1.
K(3,1) = 0.
do i = 2, n - 1
K(1,i) = h2 - ka * 2. * (x(i+1) - x(i-1)) * h2
K(2,i) = 1. - 2. * h2
K(3,i) = h2 + ka * 2. * (x(i+1) - x(i-1)) * h2
end do
K(1,n) = 0.
K(2,n) = 1.
!Write vector R
R(1) = 0.
do i = 2, n - 1
R(i) = x(i) + (x(i+1) - 2. * x(i) + x(i-1)) * h2 + &
ka * (x(i+1) - x(i-1)) * (x(i+1) - x(i-1)) * h2
end do
R(n) = 0.
end subroutine
!******************************************************************
subroutine initialValues(x0, n, tref, h)
implicit none
real*8, intent(in) :: tref, h
real*8, intent (out) :: x0(n)
- 143 -
Mtodos numricos
integer i
real*8 t, tn, kn
tn = 1020. / tref
kn = (1. + dcos(tn)) / dsin(tn)
x0(1) = -1.
do i = 2, n - 1
t = dble(i - 1) * h
x0(i) = - dcos(t) + kn * dsin(t)
end do
x0(n) = 1.
end subroutine
!******************************************************************
implicit none
real*8, intent(inout) :: a(-d:d,n), b(n)
real*8 mult
!Triangulate matrix
do pivot = 1, n - 1
disp = row - pivot
!Gauss
mult * a(1:d,pivot)
end do
end do
!Solve x
do row = n, 1, -1
end do
end subroutine
- 144 -
Mtodos numricos
10.7. Mtodo de elementos finitos

Programa 15. Radiador especial
module subroutines
implicit none
!Variables: Local means element coordinates. X: coordinates of node;
!N: shape function; DN: deriv.N; IP: Integ. points
real, save
:: localX(4,2), localN(4,4), localDN(4,2,4), localIP(4,2), alpha
real, allocatable, save :: node(:,:), K(:,:), T(:), q0(:), T0(:), Kr(:,:), Ktot(:,:), Tit(:,:)
integer, allocatable, save :: elemNode(:,:), boundIn(:), boundExt(:,:)
integer, save
:: nNode, nElem, nIn, nExt, nIP, nX
integer, save
:: maxIterations, endIT
real, save
:: error
contains
!**************************************************************
subroutine readMesh()
implicit none
integer i
real aux, aux2
open(UNIT = 5, FILE = 'input_mesh.txt', ACCESS = 'SEQUENTIAL')
!Read nodal coordinates
read(5,*) nNode
allocate (node(nNode,2))
do i = 1, nNode
read(5,*) aux, node(i,:), aux2 !First and last numbers not needed
end do
!Read Elements
read(5,*) nElem
allocate(elemNode(nElem,4))
do i = 1, nElem
read(5,*) aux, elemNode(i,:)
end do
!Read Boundary nodes that Radiate
read(5,*) nExt
allocate(boundExt(nExt,2))
do i = 1, nExt
read(5,*) aux, boundExt(i,:)
end do
- 145 -
Mtodos numricos
!Read Boundary nodes with constant Temperature

read(5,*) nIn
allocate(boundIn(nIn))
do i = 1, nIn
read(5,*) aux, boundIn(i)
end do
close(5)
end subroutine readMesh
!**************************************************************
subroutine init()
implicit none
real aux
integer i
allocate(K(nNode, nNode), Kr(nNode, nNode), KTot(nNode,nNode), &
T(nNode), T0(nNode), q0(nNode))
allocate(Tit(nNode,maxIterations))
K = 0.; Kr = 0.; KTot = 0.; T = 0.; T0 = 0.; q0 = 0.; nIP = 4; nX = 4; Tit = 0.
!Initial temperature
if (alpha .ge. 1) then
T0 = 0.9
else
T0 = alpha
end if
!Node positions
localX(1,1) = -1.;
localX(2,1) = 1.;
localX(3,1) = 1.;
localX(4,1) = -1.;
localX(node, xi-eta)
localX(1,2) = -1.
localX(2,2) = -1.
localX(3,2) = 1.
localX(4,2) = 1.
!Integration points position localIP(IP, xi-eta)

aux = 1. / sqrt(3.)
localIP = localX * aux
do i = 1, 4
!Shape functions localN(IP, shape function)
localN(i,1) = (1. - localIP(i,1)) * (1. - localIP(i,2))
localN(i,2) = (1. + localIP(i,1)) * (1. - localIP(i,2))
localN(i,3) = (1. + localIP(i,1)) * (1. + localIP(i,2))
localN(i,4) = (1. - localIP(i,1)) * (1. + localIP(i,2))
!Derivative localDN(IP, dxi - deta, shape function)
localDN(i,1,1) = - 1. + localIP(i,2); localDN(i,2,1) = - 1. + localIP(i,1)
localDN(i,1,2) = 1. - localIP(i,2); localDN(i,2,2) = - 1. - localIP(i,1)
localDN(i,1,3) = 1. + localIP(i,2); localDN(i,2,3) = 1. + localIP(i,1)
localDN(i,1,4) = - 1. - localIP(i,2); localDN(i,2,4) = 1. - localIP(i,1)
end do
- 146 -
Mtodos numricos
localDN = 0.25 * localDN; localN = 0.25 * localN

end subroutine init
!**************************************************************
subroutine isoTransform (x, dN, detJ) !Returns dN and detJ
implicit none
real, intent(in) :: x(nX,2)
real, intent(out) :: dN(nIP,2,nX), detJ(nIP)
integer i
real J(nIP,2,2), invJ(nIP,2,2)
do i = 1, nIP
!Obtain Jacobian and determinant. J = D x
J(i,:,:) = matmul(localDN(i,:,:),x)
detJ(i) = abs(J(i,1,1) * J(i,2,2) - J(i,2,1) * J(i,1,2))
!Obtain the inverse of a 2x2 matrix
invJ(i,1,1) = J(i,2,2); invJ(i,1,2) = -J(i,1,2)
invJ(i,2,1) = -J(i,2,1); invJ(i,2,2) = J(i,1,1)
invJ(i,:,:) = (1. / detJ(i)) * invJ(i,:,:)
!Obtain dN = invJ * localDN
dN(i,:,:) = matmul(invJ(i,:,:), localDN(i,:,:))
end do
end subroutine isoTransform
!**************************************************************
subroutine assembleK()
implicit none
integer i, j, l, eN(nX) !Remember nX is number of nodes per element
real x(nX,2), dN(nIP,2,nX), detJ(nIP)
real localK(nX,nX)
do i = 1, nElem
!Saves, in eN(4), the number of the nodes in the element
eN = elemNode(i,:)
!Saves, in x(4,2), the positions of the nodes
!in global coordinates of the element
do j = 1, nX
x(j,:) = node(eN(j),:)
end do
localK = 0.
call isoTransform(x, dN, detJ)
- 147 -
Mtodos numricos
!K = sum(|J| Dt D)
do j = 1, nIP
localK = localK + detJ(j) * matmul(transpose(dN(j,:,:)),dN(j,:,:))
end do
!Introduces the values in the global matrix K
do j = 1, nX
do l = 1, nX
K(eN(j), eN(l)) = K(eN(j), eN(l)) + localK(j,l)
end do
end do
end do
end subroutine assembleK
!**************************************************************
subroutine assembleQ()
implicit none
integer i, j, k, x(2)
real localQ(2), localT(2), localKr(2,2), L
real aux
!Restarts q0 and Kr
q0 = 0.; Kr = 0.
do i = 1, nExt
x = boundExt(i,:)
!Length
L = sqrt(L)
localT(1) = T0(x(1)); localT(2) = T0(x(2))
!Matrix q0
!Heat on the nodes
aux = L / alpha
localQ = localQ * aux
!Introduce values in global q
q0(x(1)) = q0(x(1)) + localQ(1)
q0(x(2)) = q0(x(2)) + localQ(2)
- 148 -
Mtodos numricos
!Matrix Kr
!Local Kr
aux = 4./6.
aux = - L / alpha
localKr = localKr * aux
!Introduce values in global Kr
do j = 1, 2
do k = 1, 2
Kr(x(j),x(k)) = Kr(x(j),x(k)) + localKr(j,k)
end do
end do
end do
endsubroutine assembleQ
!**************************************************************
subroutine innerBoundary()
implicit none
integer i, n
do i = 1, nIn
n = boundIn(i)
KTot(n,:) = 0.; KTot(n,n) = 1.
T(n) = 1. !Boundary temperature is 1
end do
end subroutine innerBoundary
!**************************************************************
subroutine solveSystem(a, b, n) !Matrix needs to be transposed
implicit none
real :: mult
do pivot = 1, n-1
do row = pivot+1, n
a(pivot+1:n,row) = a(pivot+1:n,row) - mult * &
a(pivot+1:n,pivot)
end do
end do
- 149 -
Mtodos numricos
!Obtain solutions
b(n) = b(n) / a(n,n)
do row=n-1,1,-1
end do
end subroutine
!**************************************************************
subroutine solver()
implicit none
integer i, j
real a(nNode, nNode)
logical bool
bool = .true.
do i = 1, maxIterations !bucle iterativo
!Obteins matrix Kr and vector q0
call assembleQ();
!Builds linear system Ax=b Where A=KTot and b=T
KTot = K - Kr
T = q0
!Introduces Dirichlett boundary conditions
call innerBoundary()
!Solves system
a = transpose(KTot)
call solveSystem(a, T, nNode)
!Writtes result
Tit(:,i) = T
!End loop
if(maxval(abs(T - T0)).lt. error) then
print*, " "
print*, "Final iteration: ", i
print*, " "
bool = .false.
exit
end if
!New iteration
T0 = T
print*, "Iteration ", i,"Done!"
end do
- 150 -
Mtodos numricos
endIT = i
if (bool) endIT = i - 1
end subroutine
!**************************************************************
subroutine getW()
implicit none
real L, W, localW, aux, localT(2)
integer i, x(2)
aux = 0.5
W = 0.
do i = 1, nExt
x = boundExt(i,:)
!Length
L = sqrt(L)
localT(1) = T0(x(1))*T0(x(1))*T0(x(1))*T0(x(1))
localT(2) = T0(x(2))*T0(x(2))*T0(x(2))*T0(x(2))
!Emitted power
localW = L * aux * (localT(1) + localT(2))
!Global power
W = W + localW
end do
print*, " "
print*, "Alpha:", alpha
print*, "Non-dim. power:", W
print*, " "
end subroutine getW
!**************************************************************
!**************************************************************
subroutine writeGidMesh()
implicit none
! x : Nodal Coordinates
! conec : Conectivity (Nodes of elements)
! n_nod : Number of Nodes
! n_el : Number of Elements
- 151 -
Mtodos numricos
integer n_nod, n_el, conec(4,nElem), i

real x(2,nNode)
n_nod = nNode; n_el = nElem
x(1,:) = node(:,1); x(2,:) = node(:,2)
conec = transpose(elemNode)
open(UNIT=6,FILE='radiation_analysis.post.msh',ACCESS='SEQUENTIAL',&
STATUS='REPLACE') ! Create File
write(6,*) '# postprocess mesh for GiD' ! File Header
write(6,*) 'MESH "RADIATION_FEA" dimension 2 ElemType Quadrilateral Nnode 4'
! Write Nodal Coordinates
write(6,*) 'Coordinates'
write(6,*) '# node number coordinate_x coordinate_y'
do i = 1, n_nod
write(6,*) i, x(:, i)
end do ! i
write(6,*) 'end coordinates'
! Write Surface Elements
write(6,*) 'Elements'
write(6,*) '# element node_1 node_2 node_3 node_4'
do i = 1, n_el
write(6,*) i, conec(:, i)
end do ! i
write(6,*) 'end elements'
close(6) ! Close File
end subroutine writeGidMesh
!**************************************************************
subroutine writeTemperature()
implicit none
integer n_nod, n_ite
real temperature(nNode, endIT)
integer nodeF, iter
character*(*) temp_h, scalar, endvalues, values
character*(*) header, filename
parameter (temp_h = 'Result "TEMPERATURE" "ITERATION=" ')
parameter (scalar = ' Scalar OnNodes')
parameter (endvalues = 'End Values', values = 'Values')
parameter (header = 'GiD Post Results File 1.0')
parameter (filename = 'radiation_analysis.post.res')
n_nod = nNode; n_ite = endIT; temperature(:,:) = Tit(:,1:endIT)
- 152 -
10
20
Mtodos numricos
! Format specs
format (A) ! Single character field
format (A, I0, A) ! Use to write iteration number
! Open Output File & Overwrite
open(UNIT=6, FILE=filename, ACCESS='SEQUENTIAL', &
STATUS='REPLACE')
! Write Header
write(6,10) header
! Write Temperature Distribution for Each Iteration
do iter = 1, n_ite
write(6,20) temp_h, iter, scalar
write(6,10) values
do nodeF = 1, n_nod
write(6,*) nodeF, temperature(nodeF, iter)
end do ! nodeF
write(6,10) endvalues
end do ! iter
! Close file
close(6)
end subroutine writeTemperature
end module subroutines
!**************************************************************
!
Main Program
!**************************************************************
program spaceRadiator
use subroutines
implicit none
integer i
!Program configurator
alpha
= 100.
maxIterations = 30
error
= 0.0001
!Program sequence
call readMesh();
print*, "Read Mesh Done!"
call init();
print*, "Init
Done!"
call assembleK();
print*, "Assemble K Done!"; print*," "
call solver();
print*, "Solver Done!"
call getW();
Print*, "Get W Done!"
call writeGidMesh();
call writeTemperature();
end program spaceRadiator
- 153 -
Mtodos numricos
10.8. Datos de entrada del Programa 15, radiador espacial

Los siguientes datos se utilizan como datos de entrada para el programa del radiador espacial.
Debe ser nombrado imput_mesh.txt. Consiste en una malla con
nodos para
.
288 ! Number of nodes
1, 10.000000, 0.000000, 0.000000
2, 10.000000, 0.100000, 0.000000
3, 10.000000, 0.200000, 0.000000
4, 10.000000, 0.300000, 0.000000
5, 10.000000, 0.400000, 0.000000
6, 10.000000, 0.500000, 0.000000
7, 10.000000, 0.600000, 0.000000
8, 10.000000, 0.700000, 0.000000
9, 9.208628, 0.000000, 0.000000
10, 9.208628, 0.103795, 0.000000
11, 10.000000, 0.800000, 0.000000
12, 9.208628, 0.210336, 0.000000
13, 9.208628, 0.318936, 0.000000
14, 10.000000, 0.900000, 0.000000
15, 9.208628, 0.428909, 0.000000
16, 9.208628, 0.539569, 0.000000
17, 10.000000, 1.000000, 0.000000
18, 9.208628, 0.650228, 0.000000
19, 9.208628, 0.760201, 0.000000
20, 9.208628, 0.868801, 0.000000
21, 9.208628, 0.975342, 0.000000
22, 9.208628, 1.079137, 0.000000
23, 8.427669, 0.000000, 0.000000
24, 8.427669, 0.110203, 0.000000
25, 8.427669, 0.224086, 0.000000
26, 8.427669, 0.340729, 0.000000
27, 8.427669, 0.459213, 0.000000
28, 8.427669, 0.578617, 0.000000
29, 8.427669, 0.698020, 0.000000
30, 8.427669, 0.816504, 0.000000
31, 8.427669, 0.933147, 0.000000
32, 8.427669, 1.047030, 0.000000
33, 8.427669, 1.157233, 0.000000
34, 7.666995, 0.000000, 0.000000
35, 7.666995, 0.118371, 0.000000
36, 7.666995, 0.240048, 0.000000
37, 7.666995, 0.364205, 0.000000
38, 7.666995, 0.490014, 0.000000
39, 7.666995, 0.616650, 0.000000
40, 7.666995, 0.743286, 0.000000
41, 7.666995, 0.869096, 0.000000
42, 7.666995, 0.993252, 0.000000
43, 7.666995, 1.114929, 0.000000
44, 7.666995, 1.233300, 0.000000
45, 6.935578, 0.000000, 0.000000
46, 6.935578, 0.127460, 0.000000
47, 6.935578, 0.257043, 0.000000
48, 6.935578, 0.388218, 0.000000
49, 6.935578, 0.520454, 0.000000
50, 6.935578, 0.653221, 0.000000
51, 6.935578, 0.785988, 0.000000
52, 6.935578, 0.918224, 0.000000
53, 6.935578, 1.049399, 0.000000
54, 6.935578, 1.178982, 0.000000
55, 6.935578, 1.306442, 0.000000
56, 6.241194, 0.000000, 0.000000
57, 6.241194, 0.136723, 0.000000
58, 6.241194, 0.274023, 0.000000
59, 6.241194, 0.411755, 0.000000
60, 6.241194, 0.549775, 0.000000
61, 6.241194, 0.687940, 0.000000
62, 6.241194, 0.826105, 0.000000
63, 6.241194, 0.964126, 0.000000
64, 6.241194, 1.101858, 0.000000
65, 6.241194, 1.239158, 0.000000
66, 6.241194, 1.375881, 0.000000
67, 5.590209, 0.000000, 0.000000
68, 5.590209, 0.145558, 0.000000
- 154 -
Mtodos numricos
69, 5.590209, 0.290142, 0.000000

70, 5.590209, 0.433997, 0.000000
71, 5.590209, 0.577365, 0.000000
72, 5.590209, 0.720490, 0.000000
73, 5.590209, 0.863614, 0.000000
74, 5.590209, 1.006982, 0.000000
75, 5.590209, 1.150837, 0.000000
76, 5.590209, 1.295421, 0.000000
77, 5.590209, 1.440979, 0.000000
78, 4.987445, 0.000000, 0.000000
79, 4.987445, 0.153537, 0.000000
80, 4.987445, 0.304800, 0.000000
81, 4.987445, 0.454357, 0.000000
82, 4.987445, 0.602777, 0.000000
83, 4.987445, 0.750628, 0.000000
84, 4.987445, 0.898479, 0.000000
85, 4.987445, 1.046899, 0.000000
86, 4.987445, 1.196456, 0.000000
87, 4.987445, 1.347718, 0.000000
88, 4.987445, 1.501255, 0.000000
89, 4.436137, 0.000000, 0.000000
90, 4.436137, 0.160408, 0.000000
91, 4.436137, 0.317636, 0.000000
92, 4.436137, 0.472480, 0.000000
93, 4.436137, 0.625734, 0.000000
94, 4.436137, 0.778193, 0.000000
95, 4.436137, 0.930652, 0.000000
96, 4.436137, 1.083906, 0.000000
97, 4.436137, 1.238750, 0.000000
98, 4.436137, 1.395978, 0.000000
99, 4.436137, 1.556386, 0.000000
100, 3.937967, 0.000000, 0.000000
101, 3.937967, 0.166071, 0.000000
102, 3.937967, 0.328508, 0.000000
103, 3.937967, 0.488220, 0.000000
104, 3.937967, 0.646115, 0.000000
105, 3.937967, 0.803102, 0.000000
106, 3.937967, 0.960088, 0.000000
107, 3.937967, 1.117983, 0.000000
108, 3.937967, 1.277695, 0.000000
109, 3.937967, 1.440132, 0.000000
110, 3.937967, 1.606203, 0.000000
111, 3.493172, 0.000000, 0.000000
112, 3.493172, 0.170548, 0.000000
113, 3.493172, 0.337443, 0.000000
114, 3.493172, 0.501598, 0.000000
115, 3.493172, 0.663926, 0.000000
116, 3.493172, 0.825341, 0.000000
117, 3.493172, 0.986756, 0.000000
118, 3.493172, 1.149085, 0.000000
119, 3.493172, 1.313239, 0.000000
120, 3.493172, 1.480134, 0.000000
121, 3.493172, 1.650683, 0.000000
122, 3.100706, 0.000000, 0.000000
123, 3.100706, 0.173947, 0.000000
124, 3.100706, 0.344591, 0.000000
125, 3.100706, 0.512758, 0.000000
126, 3.100706, 0.679274, 0.000000
127, 3.100706, 0.844965, 0.000000
128, 3.100706, 1.010655, 0.000000
129, 3.100706, 1.177171, 0.000000
130, 3.100706, 1.345338, 0.000000
131, 3.100706, 1.515982, 0.000000
132, 3.100706, 1.689929, 0.000000
133, 2.758440, 0.000000, 0.000000
134, 2.758440, 0.176421, 0.000000
135, 2.758440, 0.350172, 0.000000
136, 2.758440, 0.521920, 0.000000
137, 2.758440, 0.692333, 0.000000
138, 2.758440, 0.862078, 0.000000
139, 2.758440, 1.031823, 0.000000
140, 2.758440, 1.202236, 0.000000
141, 2.758440, 1.373984, 0.000000
142, 2.758440, 1.547735, 0.000000
143, 2.758440, 1.724156, 0.000000
144, 2.463382, 0.000000, 0.000000
145, 2.463382, 0.178145, 0.000000
- 155 -

146,
147,
148,
149,
150,
151,
152,
153,
154,
155,
156,
157,
158,
159,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
174,
175,
176,
177,
178,
179,
180,
181,
182,
183,
184,
185,
186,
187,
188,
189,
190,
191,
192,
193,
194,
195,
196,
197,
198,
199,
200,
201,
202,
203,
204,
205,
206,
207,
208,
209,
210,
211,
212,
213,
214,
215,
216,
217,
218,
219,
220,
221,
222,
Mtodos numricos
2.463382,
2.463382,
2.463382,
2.463382,
2.463382,
2.463382,
2.463382,
2.463382,
2.463382,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.211913,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
2.000000,
1.821629,
1.815673,
1.815169,
2.000000,
1.815784,
1.812997,
1.811110,
1.808492,
1.806234,
1.804310,
1.808224,
1.636086,
1.630681,
1.630370,
1.813192,
1.625911,
1.619998,
1.619546,
1.616625,
1.608731,
1.606702,
1.615396,
1.446553,
1.443569,
1.441455,
1.622146,
1.432886,
1.421536,
1.424186,
1.405719,
1.400527,
1.400477,
1.275691,
1.268725,
1.264471,
1.417036,
1.244228,
1.427056,
1.234777,
1.202281,
1.123014,
1.121434,
1.175523,
1.111057,
1.131105,
1.180136,
1.081815,
0.354438,
0.529341,
0.703317,
0.876831,
1.050344,
1.224321,
1.399224,
1.575517,
1.753662,
0.000000,
0.179288,
0.357637,
0.535284,
0.712461,
0.889404,
1.066347,
1.243525,
1.421171,
1.599521,
1.778809,
0.000000,
0.180000,
0.360000,
0.540000,
0.720000,
0.900000,
1.080000,
1.260000,
1.440000,
1.620000,
0.000000,
0.180872,
0.361012,
1.800000,
0.541894,
0.719583,
0.898145,
1.079273,
1.266466,
1.455508,
1.637391,
0.000000,
0.176823,
0.353756,
1.818681,
0.528767,
0.705203,
0.888848,
1.072482,
1.266208,
1.463877,
1.655375,
0.167221,
0.000000,
0.338019,
1.837785,
0.508613,
0.683612,
0.865111,
1.052398,
1.256977,
1.462519,
0.151792,
0.000000,
0.305980,
1.666282,
0.463444,
1.857294,
0.835586,
0.646075,
0.133967,
0.000000,
1.014019,
0.264424,
0.816136,
1.246738,
0.395229,
- 156 -
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
Mtodos numricos
223, 1.194695, 1.469996,

224, 1.215938, 1.677771,
225, 1.069449, 0.718869,
226, 1.228136, 1.877186,
227, 1.072855, 0.892884,
228, 1.032974, 0.522098,
229, 1.000000, 0.000000,
230, 0.993712, 0.111964,
231, 0.974928, 0.222521,
232, 0.985400, 0.800166,
233, 0.993378, 0.940211,
234, 0.943883, 0.330279,
235, 0.956961, 0.619959,
236, 0.984128, 1.042489,
237, 0.900969, 0.433884,
238, 0.908253, 0.880242,
239, 0.881762, 0.709896,
240, 0.968509, 1.486987,
241, 1.000807, 1.700009,
242, 0.918269, 1.240118,
243, 0.846724, 0.532032,
244, 1.025621, 1.897438,
245, 0.843327, 0.974604,
246, 0.802854, 0.795968,
247, 0.781831, 0.623490,
248, 0.751021, 1.088769,
249, 0.723119, 0.883010,
250, 0.707107, 0.707107,
251, 0.791544, 1.730488,
252, 0.755425, 1.532664,
253, 0.820497, 1.917950,
254, 0.700764, 1.331699,
255, 0.623490, 0.781831,
256, 0.628707, 0.961914,
257, 0.608334, 1.168378,
258, 0.532032, 0.846724,
259, 0.513908, 1.024962,
260, 0.592549, 1.751134,
261, 0.556982, 1.567234,
262, 0.615372, 1.938463,
263, 0.516188, 1.380476,
264, 0.433884, 0.900969,
265, 0.460891, 1.216817,
266, 0.395504, 1.069903,
267, 0.330279, 0.943883,
268, 0.369893, 1.582445,
269, 0.340301, 1.404842,
270, 0.392043, 1.770125,
271, 0.304717, 1.245069,
272, 0.410248, 1.958975,
273, 0.264905, 1.100687,
274, 0.222521, 0.974928,
275, 0.152769, 1.257928,
276, 0.132989, 1.115929,
277, 0.168770, 1.423452,
278, 0.111964, 0.993712,
279, 0.182011, 1.598901,
280, 0.195481, 1.787944,
281, 0.205124, 1.979488,
282, 0.000000, 1.000000,
283, 0.000000, 1.118304,
284, 0.000000, 1.261798,
285, 0.000000, 1.432135,
286, 0.000000, 1.621423,
287, 0.000000, 1.810712,
288, 0.000000, 2.000000,
249 ! Number of elements
1,282, 278, 276, 283
2,230, 229, 217, 216
3,278, 274, 273, 276
4,231, 230, 216, 219
5,274, 267, 266, 273
6,234, 231, 219, 222
7,267, 264, 259, 266
8,237, 234, 222, 228
9,264, 258, 256, 259
10,243, 237, 228, 235
- 157 -
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000
0.000000

11,258,
12,247,
13,255,
14,250,
15,284,
16,217,
17,285,
18,209,
19,176,
20,175,
21,167,
22,174,
23,168,
24,173,
25,169,
26,172,
27,170,
28,171,
29,187,
30,199,
31,288,
32,286,
33,287,
34,190,
35,201,
36,213,
37,226,
38,272,
39,244,
40,262,
41,253,
42,219,
43,222,
44,228,
45,275,
46,235,
47,239,
48,246,
49,249,
50,256,
51,259,
52,266,
53,273,
54,277,
55,186,
56,184,
57,183,
58,182,
59,181,
60,180,
61,177,
62,178,
63,208,
64,198,
65,279,
66,280,
67,260,
68,197,
69,251,
70,211,
71,241,
72,224,
73,212,
74,200,
75,191,
76,212,
77,271,
78,268,
79,265,
80,261,
81,196,
82,194,
83,193,
84,192,
85,207,
86,240,
87,223,
Mtodos numricos
255,
243,
250,
247,
283,
209,
284,
199,
166,
179,
168,
175,
169,
174,
170,
173,
171,
172,
176,
187,
287,
285,
286,
201,
213,
226,
244,
281,
253,
272,
262,
216,
219,
222,
276,
228,
235,
239,
246,
249,
256,
259,
266,
275,
197,
185,
184,
183,
182,
181,
178,
180,
198,
188,
277,
279,
270,
211,
260,
224,
251,
241,
210,
189,
192,
202,
265,
269,
257,
263,
207,
195,
194,
193,
223,
252,
240,
249,
235,
246,
239,
276,
208,
275,
198,
167,
190,
178,
186,
180,
185,
181,
184,
182,
183,
177,
188,
280,
277,
279,
197,
211,
224,
241,
280,
251,
270,
260,
208,
210,
212,
273,
215,
225,
232,
238,
245,
248,
257,
265,
271,
196,
196,
195,
194,
193,
192,
189,
191,
200,
189,
269,
268,
268,
207,
261,
223,
252,
240,
200,
191,
203,
203,
263,
263,
254,
254,
206,
206,
205,
204,
221,
254,
242,
256
239
249
246
275
216
277
208
177
186
177
185
178
184
180
183
181
182
188
198
281
279
280
186
197
211
224
270
241
260
251
210
212
215
271
225
232
238
245
248
257
265
271
269
185
195
194
193
192
191
188
189
210
200
268
270
261
196
252
207
240
223
202
202
202
215
269
261
263
252
195
205
204
203
206
242
221
- 158 -
Mtodos numricos
88,254, 257, 248, 242

89,245, 238, 233, 236
90,238, 232, 227, 233
91,232, 225, 220, 227
92,220, 225, 215, 214
93,204, 214, 215, 203
94,248, 245, 236, 242
95,233, 227, 218, 236
96,227, 220, 214, 218
97,214, 204, 205, 218
98,205, 206, 221, 218
99,221, 242, 236, 218
100,2, 10, 9, 1
101,3, 12, 10, 2
102,4, 13, 12, 3
103,5, 15, 13, 4
104,6, 16, 15, 5
105,7, 18, 16, 6
106,8, 19, 18, 7
107,11, 20, 19, 8
108,14, 21, 20, 11
109,17, 22, 21, 14
110,10, 24, 23, 9
111,12, 25, 24, 10
112,13, 26, 25, 12
113,15, 27, 26, 13
114,16, 28, 27, 15
115,18, 29, 28, 16
116,19, 30, 29, 18
117,20, 31, 30, 19
118,21, 32, 31, 20
119,22, 33, 32, 21
120,24, 35, 34, 23
121,25, 36, 35, 24
122,26, 37, 36, 25
123,27, 38, 37, 26
124,28, 39, 38, 27
125,29, 40, 39, 28
126,30, 41, 40, 29
127,31, 42, 41, 30
128,32, 43, 42, 31
129,33, 44, 43, 32
130,35, 46, 45, 34
131,36, 47, 46, 35
132,37, 48, 47, 36
133,38, 49, 48, 37
134,39, 50, 49, 38
135,40, 51, 50, 39
136,41, 52, 51, 40
137,42, 53, 52, 41
138,43, 54, 53, 42
139,44, 55, 54, 43
140,46, 57, 56, 45
141,47, 58, 57, 46
142,48, 59, 58, 47
143,49, 60, 59, 48
144,50, 61, 60, 49
145,51, 62, 61, 50
146,52, 63, 62, 51
147,53, 64, 63, 52
148,54, 65, 64, 53
149,55, 66, 65, 54
150,57, 68, 67, 56
151,58, 69, 68, 57
152,59, 70, 69, 58
153,60, 71, 70, 59
154,61, 72, 71, 60
155,62, 73, 72, 61
156,63, 74, 73, 62
157,64, 75, 74, 63
158,65, 76, 75, 64
159,66, 77, 76, 65
160,68, 79, 78, 67
161,69, 80, 79, 68
162,70, 81, 80, 69
163,71, 82, 81, 70
164,72, 83, 82, 71
- 159 -
Mtodos numricos
165,73, 84, 83, 72

166,74, 85, 84, 73
167,75, 86, 85, 74
168,76, 87, 86, 75
169,77, 88, 87, 76
170,79, 90, 89, 78
171,80, 91, 90, 79
172,81, 92, 91, 80
173,82, 93, 92, 81
174,83, 94, 93, 82
175,84, 95, 94, 83
176,85, 96, 95, 84
177,86, 97, 96, 85
178,87, 98, 97, 86
179,88, 99, 98, 87
180,90, 101, 100, 89
181,91, 102, 101, 90
182,92, 103, 102, 91
183,93, 104, 103, 92
184,94, 105, 104, 93
185,95, 106, 105, 94
186,96, 107, 106, 95
187,97, 108, 107, 96
188,98, 109, 108, 97
189,99, 110, 109, 98
190,101, 112, 111, 100
191,102, 113, 112, 101
192,103, 114, 113, 102
193,104, 115, 114, 103
194,105, 116, 115, 104
195,106, 117, 116, 105
196,107, 118, 117, 106
197,108, 119, 118, 107
198,109, 120, 119, 108
199,110, 121, 120, 109
200,112, 123, 122, 111
201,113, 124, 123, 112
202,114, 125, 124, 113
203,115, 126, 125, 114
204,116, 127, 126, 115
205,117, 128, 127, 116
206,118, 129, 128, 117
207,119, 130, 129, 118
208,120, 131, 130, 119
209,121, 132, 131, 120
210,123, 134, 133, 122
211,124, 135, 134, 123
212,125, 136, 135, 124
213,126, 137, 136, 125
214,127, 138, 137, 126
215,128, 139, 138, 127
216,129, 140, 139, 128
217,130, 141, 140, 129
218,131, 142, 141, 130
219,132, 143, 142, 131
220,134, 145, 144, 133
221,135, 146, 145, 134
222,136, 147, 146, 135
223,137, 148, 147, 136
224,138, 149, 148, 137
225,139, 150, 149, 138
226,140, 151, 150, 139
227,141, 152, 151, 140
228,142, 153, 152, 141
229,143, 154, 153, 142
230,145, 156, 155, 144
231,146, 157, 156, 145
232,147, 158, 157, 146
233,148, 159, 158, 147
234,149, 160, 159, 148
235,150, 161, 160, 149
236,151, 162, 161, 150
237,152, 163, 162, 151
238,153, 164, 163, 152
239,154, 165, 164, 153
240,156, 167, 166, 155
241,157, 168, 167, 156
- 160 -
Mtodos numricos
242,158, 169, 168, 157

243,159, 170, 169, 158
244,160, 171, 170, 159
245,161, 172, 171, 160
246,162, 173, 172, 161
247,163, 174, 173, 162
248,164, 175, 174, 163
249,165, 179, 175, 164
34 ! Number of radiating faces
1, 179,190
2, 281,288
3, 190,201
4, 201,213
5, 213,226
6, 226,244
7, 272,281
8, 244,253
9, 262,272
10, 253,262
11, 1,2
12, 2,3
13, 3,4
14, 4,5
15, 5,6
16, 6,7
17, 7,8
18, 8,11
19, 11,14
20, 17,22
21, 22,33
22, 33,44
23, 44,55
24, 55,66
25, 66,77
26, 77,88
27, 88,99
28, 99,110
29, 110,121
30, 121,132
31, 132,143
32, 143,154
33, 154,165
34, 165,179
15 ! Number of fixed temperature nodes
1, 229
2, 230
3, 231
4, 234
5, 237
6, 243
7, 247
8, 250
9, 255
10, 258
11, 264
12, 267
13, 274
14, 278
15, 282
- 161 -

Métodos Numéricos Ingeniería Aeronáutica

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Métodos Numéricos Ingeniería Aeronáutica

Încărcat de

Drepturi de autor:

Formate disponibile

Andrs Zarabozo

Mtodos Numricos. Apuntes

Andrs Zarabozo Martnez

Acerca de estos apuntes

Compartir Copiar, distribuir y comunicar pblicamente la obra.

Bajo las condiciones siguientes:

Reconocimiento Debe reconocer al autor de la obra original (pero no de una

Andrs Zarabozo Martnez

Tipos de variables .......................................................................................................... 7

Expresiones aritmticas ................................................................................................ 7

Bucles y condiciones ..................................................................................................... 8

Vectores y matrices ....................................................................................................... 9

Lectura y escritura de datos ........................................................................................ 12

Programa 1. Mnimo error de un tipo de variable .............................................................. 13

Interpolacin cbica en un solo intervalo ................................................................... 18

Programa 3. Entrada de datos e interpolacin ................................................................... 20

Frmula de Newton-Cotes .......................................................................................... 23

Regla del punto medio ................................................................................................ 25

Regla del trapecio ........................................................................................................ 25

Regla de Simpson ........................................................................................................ 27

Extrapolacin de Richardson ....................................................................................... 28

Programa 4. Obtencin de la serie de Fourier .................................................................... 30

Programa 5. Iteraciones y extrapolacin ............................................................................ 33

Resolucin numrica de ecuaciones no lineales

Mtodo de la biseccin ............................................................................................... 36

Mtodo de Newton - Raphson .................................................................................... 36

Mtodo de regula falsi ................................................................................................ 38

Teorema del punto fijo................................................................................................ 39

Andrs Zarabozo Martnez

Programa 6. Deflexin de un cable ..................................................................................... 41

Resolucin numrica de sistemas lineales

Mtodo de eliminacin de Gauss................................................................................ 45

Matrices mal condicionadas........................................................................................ 46

Mtodo del gradiente conjugado................................................................................ 51

Ejemplo de aplicacin del mtodo del gradiente conjugado ...................................... 56

Programa 1. Resolucin de un sistema mediante Gauss .................................................... 58

Resolucin numrica de sistemas no lineales

Mtodo de Newton para sistemas no lineales............................................................ 72

Ecuaciones diferenciales, problemas de valor inicial

Tipos de ecuaciones diferenciales ............................................................................... 74

Ejemplo de resolucin mediante el mtodo de Euler. ................................................ 75

Mtodo implcito de Euler........................................................................................... 75

Mtodo de Heun ......................................................................................................... 76

Mtodo de Runge-Kutta de segundo orden ............................................................... 77

Mtodo de Runge-Kutta de rdenes superiores......................................................... 78

Mtodo adaptativo de Runge-Kutta ........................................................................... 80

7.10. Mtodo de Runge-Kutta para EDOs de grados superiores ......................................... 81

Mtodo de diferencias finitas

Diferencias finitas en una dimensin. ......................................................................... 82

Diferencias finitas en dos dimensiones ....................................................................... 83

Andrs Zarabozo Martnez

Ejemplo de problema mecnico.................................................................................. 84

Programa 6. Ejemplo de problema mecnico ..................................................................... 90

Mtodo de elementos finitos

Forma fuerte del problema ......................................................................................... 96

Mtodo de Rayleigh-Ritz y mtodo de Galerkin ......................................................... 96

Ejemplo de formulacin fuerte para problema estructural ........................................ 97

Funciones de forma ................................................................................................... 100

Cuadratura de Gauss ................................................................................................. 101

Tipos de elementos en 2D ......................................................................................... 101

Ejemplo de problema trmico................................................................................... 105

Programa ................................................................................................................... 111

Programa 7. Radiador espacial .......................................................................................... 111