F90 raices
0 recomendaciones271 vistas
Este documento presenta subrutinas en Fortran 95 para resolver ecuaciones no lineales de una variable mediante métodos numéricos iterativos como bisección, Newton-Raphson, Birge-Vieta y secante. Explica los principios básicos de cada método e implementa cada uno como una subrutina que acepta como entrada la función, aproximaciones iniciales, tolerancia y número máximo de iteraciones, devolviendo la raíz aproximada o un código de error. Además, define un módulo para encapsular las subrutinas y tipos de
![error es distinta de cero, entonces ocurrió un error. La naturaleza del error dependerá del método,
pero un error común a todos ellos es que el número máximo de iteraciones fue alcanzado.
Con el fin de aprovechar la capacidad de Fortran 95 de detectar errores de tipo en los argu-
mentos al llamar a las subrutinas, debemos hacer explícita la interface de las mismas. La forma
más simple y poderosa de efectuar ésto consiste en agrupar las mismas en un módulo, al que
denominaremos roots. En nuestra implementación todas las cantidades reales serán de la clase de
doble precisión, la cual, para máxima flexibilidad, está definida en forma paramétrica utilizando
el modulo precision2
, el cual, por completitud en la exposición, incluimos a continuación junto
con el esquema de nuestro módulo roots.
MODULE precision
IMPLICIT NONE
INTEGER, PARAMETER :: SP = SELECTED_REAL_KIND(6,37)
INTEGER, PARAMETER :: DP = SELECTED_REAL_KIND(15,307)
END MODULE precision
MODULE roots
CONTAINS
SUBROUTINE biseccion(f,a,b,n,tol,raiz,clave)
....
END SUBROUTINE biseccion
SUBROUTINE newton(f,df,x0,n,tol,raiz,clave)
....
END SUBROUTINE newton
SUBROUTINE birge_vieta(a,m,x0,n,tol,raiz,clave)
....
END SUBROUTINE birge_vieta
SUBROUTINE secante(f,x0,x1,n,tol,raiz,clave)
....
END SUBROUTINE secante
SUBROUTINE punto_fijo(f,x0,n,tol,raiz,clave)
....
END SUBROUTINE punto_fijo
END MODULE roots
El código correspondiente a cada subrutina, que debe insertarse donde se encuentran los puntos
suspensivos, será discutido por separado en las siguientes secciones.
2. Método de bisección
El método de bisección comienza con un intervalo [a, b ] que contiene a la raíz. Entonces se
computa el punto medio x0 = (a + b)/2 del mismo y se determina en cual de los dos subintervalos
[a, x0] o [x0, b ] se encuentra la raíz analizando el cambio de signo de f(x) en los extremos. El
procedimiento se vuelve a repetir con el nuevo intervalo así determinado.
2La discusión sobre el uso de este módulo se encuentra en el apunte Un módulo para parametrizar las clases de
tipos de datos reales.
2](https://image.slidesharecdn.com/f90-raices-160412213003/85/F90-raices-2-320.jpg)
![Es claro que la raíz es acotada en cada paso por el intervalo así generado y que una estimación
del error cometido en aproximar la raíz por el punto medio de dicho intervalo es igual a la mitad
de la longitud del mismo. Esta estimación es utilizada, en la siguiente implementación del método,
como criterio de paro para la sucesión de aproximaciones.
SUBROUTINE biseccion(f,a,b,n,tol,raiz,clave)
! ---------------------------------------------------
! METODO DE BISECCION para encontrar una solución
! de f(x)=0 dada la función continua f en el intervalo
! [a,b] donde f(a) y f(b) tienen signos opuestos.
! ---------------------------------------------------
! Bloque de declaración de argumentos
! ---------------------------------------------------
USE precision, WP => DP
IMPLICIT NONE
INTERFACE
FUNCTION f(x) ! Función que define la ecuación
USE precision, WP => DP
IMPLICIT NONE
REAL(WP) :: f
REAL(WP), INTENT(IN) :: x
END FUNCTION f
END INTERFACE
REAL(WP), INTENT(IN) :: a ! Extremo izquierdo del intervalo inicial
REAL(WP), INTENT(IN) :: b ! Extremo derecho del intervalo inicial
INTEGER, INTENT(INOUT) :: n ! Número máximo de iteraciones/ iteraciones realizadas
REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error absoluto
REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz
INTEGER, INTENT(OUT) :: clave ! Clave de éxito:
! 0 : éxito
! >0 : iteraciones excedidas
! <0 : no se puede proceder (f de igual signo en a y b)
! ---------------------------------------------------
! Bloque de declaración de variables locales
! ---------------------------------------------------
INTEGER :: i
REAL(WP) :: xl, xr, signfxl, error
! ---------------------------------------------------
! Bloque de procesamiento
! ---------------------------------------------------
xl = a
xr = b
signfxl = SIGN(1.0_WP,f(xl))
IF (signfxl*f(xr) > 0.0_WP) THEN
clave = -1
RETURN
ENDIF
DO i=1,n
error = (xr-xl)*0.5_WP
raiz = xl + error
IF (error < tol) THEN
clave = 0
n = i
RETURN
ENDIF
IF (signfxl*f(raiz) > 0.0_WP) THEN
xl = raiz
ELSE
3](https://image.slidesharecdn.com/f90-raices-160412213003/85/F90-raices-3-320.jpg)
F90 raices
- 1. Subrutinas en Fortran 95 para la resolución de ecuaciones de una variable Pablo Santamaría v0.1 (Junio 2009) 1. Introducción En general, las raíces de una ecuación no lineal f(x) = 0 no pueden ser obtenidas por fórmulas explícitas cerradas, con lo que no es posible obtenerlas en forma exacta. De este modo, para resolver la ecuación nos vemos obligados a obtener soluciones aproximadas a través de algún método numérico. Estos métodos son iterativos, esto es, a partir de una o más aproximaciones iniciales para la raíz, generan una sucesión de aproximaciones x0, x1, x2, . . . que esperamos convergan al valor de la raíz α buscada. El proceso iterativo se continúa hasta que la aproximación se encuentra próxima a la raíz dentro de una tolerancia > 0 preestablecida. Como la raíz no es conocida, dicha proximidad, medida por el error absoluto |xn+1 − α|, no puede ser computada. Sin un conocimiento adicional de la función f(x) o su raíz, el mejor criterio para detener las iteraciones consiste en proceder hasta que la desigualdad |xn+1 − xn| |xn+1| < se satisfaga, dado que esta condición estima en cada paso el error relativo. Ahora bien, puede ocurrir en ciertas circunstancias que la desigualdad anterior nunca se satisfaga, ya sea por que la sucesión de aproximaciones diverge o bien que la tolerancia escogida no es razonable. En tal caso el método iterativo no se detiene nunca. Para evitar este problema consideramos además un número máximo de iteraciones a realizarse. Si este número es excedido entonces el problema debe ser analizado con más cuidado. ¿Cómo se escoge un valor correcto para las aproximaciones iniciales requeridas por los méto- dos? No existe una respuesta general para esta cuestión. Para el método de bisección es suficiente conocer un intervalo que contenga la raíz, pero para el método de Newton, por ejemplo, la apro- ximación tiene que estar suficientemente cercana a la raíz para que funcione 1 . En cualquier caso primeras aproximaciones iniciales para las raíces pueden ser obtenidas graficando la función f(x). En las siguientes secciones presentamos implementaciones de los métodos numéricos usuales como subrutinas Fortran. Con el fin de proporcionar subrutinas de propósito general, las mismas tienen entre sus argumentos a la función f involucrada, la cual pude ser entonces implementada por el usuario como un subprograma FUNCTION externo con el nombre que quiera. Otros argumentos que requieren estas subrutinas son los valores para las aproximaciones iniciales que necesite el método, una tolerancia para la aproximación final de la raíz y un número máximo de iteraciones. La raíz aproximada es devuelta en otro de los argumentos. Dado que el método puede fallar utilizamos también una variable entera como clave de error para advertir al programa principal. Por convención tomaremos que si dicha clave es igual a cero, entonces el método funcionó correctamente y el valor devuelto es la raíz aproximada dentro de la tolerancia preescrita. En cambio, si la clave de 1De hecho, efectuando algunas iteraciones del método de bisección podemos obtener una buena aproximación para iniciar el método de Newton. 1
- 2. error es distinta de cero, entonces ocurrió un error. La naturaleza del error dependerá del método, pero un error común a todos ellos es que el número máximo de iteraciones fue alcanzado. Con el fin de aprovechar la capacidad de Fortran 95 de detectar errores de tipo en los argu- mentos al llamar a las subrutinas, debemos hacer explícita la interface de las mismas. La forma más simple y poderosa de efectuar ésto consiste en agrupar las mismas en un módulo, al que denominaremos roots. En nuestra implementación todas las cantidades reales serán de la clase de doble precisión, la cual, para máxima flexibilidad, está definida en forma paramétrica utilizando el modulo precision2 , el cual, por completitud en la exposición, incluimos a continuación junto con el esquema de nuestro módulo roots. MODULE precision IMPLICIT NONE INTEGER, PARAMETER :: SP = SELECTED_REAL_KIND(6,37) INTEGER, PARAMETER :: DP = SELECTED_REAL_KIND(15,307) END MODULE precision MODULE roots CONTAINS SUBROUTINE biseccion(f,a,b,n,tol,raiz,clave) .... END SUBROUTINE biseccion SUBROUTINE newton(f,df,x0,n,tol,raiz,clave) .... END SUBROUTINE newton SUBROUTINE birge_vieta(a,m,x0,n,tol,raiz,clave) .... END SUBROUTINE birge_vieta SUBROUTINE secante(f,x0,x1,n,tol,raiz,clave) .... END SUBROUTINE secante SUBROUTINE punto_fijo(f,x0,n,tol,raiz,clave) .... END SUBROUTINE punto_fijo END MODULE roots El código correspondiente a cada subrutina, que debe insertarse donde se encuentran los puntos suspensivos, será discutido por separado en las siguientes secciones. 2. Método de bisección El método de bisección comienza con un intervalo [a, b ] que contiene a la raíz. Entonces se computa el punto medio x0 = (a + b)/2 del mismo y se determina en cual de los dos subintervalos [a, x0] o [x0, b ] se encuentra la raíz analizando el cambio de signo de f(x) en los extremos. El procedimiento se vuelve a repetir con el nuevo intervalo así determinado. 2La discusión sobre el uso de este módulo se encuentra en el apunte Un módulo para parametrizar las clases de tipos de datos reales. 2
- 3. Es claro que la raíz es acotada en cada paso por el intervalo así generado y que una estimación del error cometido en aproximar la raíz por el punto medio de dicho intervalo es igual a la mitad de la longitud del mismo. Esta estimación es utilizada, en la siguiente implementación del método, como criterio de paro para la sucesión de aproximaciones. SUBROUTINE biseccion(f,a,b,n,tol,raiz,clave) ! --------------------------------------------------- ! METODO DE BISECCION para encontrar una solución ! de f(x)=0 dada la función continua f en el intervalo ! [a,b] donde f(a) y f(b) tienen signos opuestos. ! --------------------------------------------------- ! Bloque de declaración de argumentos ! --------------------------------------------------- USE precision, WP => DP IMPLICIT NONE INTERFACE FUNCTION f(x) ! Función que define la ecuación USE precision, WP => DP IMPLICIT NONE REAL(WP) :: f REAL(WP), INTENT(IN) :: x END FUNCTION f END INTERFACE REAL(WP), INTENT(IN) :: a ! Extremo izquierdo del intervalo inicial REAL(WP), INTENT(IN) :: b ! Extremo derecho del intervalo inicial INTEGER, INTENT(INOUT) :: n ! Número máximo de iteraciones/ iteraciones realizadas REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error absoluto REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz INTEGER, INTENT(OUT) :: clave ! Clave de éxito: ! 0 : éxito ! >0 : iteraciones excedidas ! <0 : no se puede proceder (f de igual signo en a y b) ! --------------------------------------------------- ! Bloque de declaración de variables locales ! --------------------------------------------------- INTEGER :: i REAL(WP) :: xl, xr, signfxl, error ! --------------------------------------------------- ! Bloque de procesamiento ! --------------------------------------------------- xl = a xr = b signfxl = SIGN(1.0_WP,f(xl)) IF (signfxl*f(xr) > 0.0_WP) THEN clave = -1 RETURN ENDIF DO i=1,n error = (xr-xl)*0.5_WP raiz = xl + error IF (error < tol) THEN clave = 0 n = i RETURN ENDIF IF (signfxl*f(raiz) > 0.0_WP) THEN xl = raiz ELSE 3
- 4. xr = raiz ENDIF ENDDO clave = 1 RETURN END SUBROUTINE biseccion 3. Método de Newton–Raphson El método de Newton comienza con una aproximación inicial x0 dada, a partir de la cual se genera la sucesión de aproximaciones x1, x2, . . ., siendo xn+1 la abscisa del punto de intersección del eje x con la recta tangente a f(x) que pasa por el punto (xn, f(xn)). Esto conduce a la fórmula de iteración xn+1 = xn − f(xn) f (xn) , n = 1, 2, . . . Nuestra implementación de la subrutina correspondiente requiere que se pase también como argumento no sólo la funcion f(x), sino también su derivada f (x), la cual debe ser implementada por el usuario, al igual que f(x), como una FUNCTION. SUBROUTINE newton(f,df,x0,n,tol,raiz,clave) ! --------------------------------------------------- ! Metodo DE NEWTON-RAPHSON para encontrar una ! solución de f(x)=0 dada la función derivable ! f y una aproximación inicial x0. ! --------------------------------------------------- ! Bloque de declaración de argumentos ! --------------------------------------------------- USE precision, WP => DP IMPLICIT NONE INTERFACE FUNCTION f(x) ! Función que define la ecuación USE precision, WP => DP IMPLICIT NONE REAL(WP) :: f REAL(WP), INTENT(IN) :: x END FUNCTION f FUNCTION df(x) ! Derivada de la función que define la ecuación USE precision, WP => DP IMPLICIT NONE REAL(WP) :: df REAL(WP), INTENT(IN) :: x END FUNCTION df END INTERFACE REAL(WP), INTENT(IN) :: x0 ! Aproximación inicial a la raíz INTEGER, INTENT(INOUT) :: n ! Número máximo de iteraciones/ iteraciones realizadas REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error relativo REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz INTEGER, INTENT(OUT) :: clave ! Clave de éxito: ! 0 : éxito ! >0 : iteraciones excedidas ! --------------------------------------------------- ! Declaración de variables locales ! --------------------------------------------------- INTEGER :: i REAL(WP) :: xx0 4
- 5. ! --------------------------------------------------- ! Bloque de procesamiento ! --------------------------------------------------- xx0 = x0 DO i=1,n raiz = xx0 - f(xx0)/df(xx0) IF (ABS((raiz-xx0)/raiz) < tol) THEN clave = 0 n = i RETURN ENDIF xx0 = raiz END DO clave = 1 RETURN END SUBROUTINE newton 4. Método de Newton para ecuaciones algebraicas En el caso particular en que f(x) es un polinomio, el método de Newton puede ser eficientemente implementado si la evaluación de f(xn) (y su derivada) es realizada por el método iterativo de Horner. En efecto, supongamos que f(x) es un polinomio de grado m: f(x) = a0 + a1x + a2x2 + · · · + amxm , la evaluación de f(xn) por la regla de Horner procede computando bm = am bk = ak + bk+1xn k = m − 1, . . . , 0 siendo, entonces b0 = f(xn), en tanto que f (xn) es computada haciendo cm = bm ck = bk + ck+1xn k = m − 1, . . . , 1 siendo, entonces c1 = f (xn). El método de Newton se reduce así a xn+1 = xn − b0 c1 El procedimiento resultante se conoce a menudo como método de Birge–Vieta. Nuestra implementación en la siguiente subrutina pasa los coeficientes del polinomio en un arreglo a de (m+1) componentes, siendo m el grado del polinomio (valor que también es requerido como argumento). En la subrutina, para simplificar el tratamiento de los subíndices, el arreglo es declarado con el índice inferior 0, no 1, de manera que a(0) = a0, a(1) = a1, . . . , a(M) = am. SUBROUTINE birge_vieta(a,m,x0,n,tol,raiz,clave) ! --------------------------------------------------- ! METODO DE BIRGE-VIETA para resolver ECUACIONES ! ALGEBRAICAS: P (x) = 0 donde P es un polinomio de 5
- 6. ! grado m de coeficientes reales. ! El método se basa en el método de Newton-Raphson ! implementando el esquema de Horner para la evalua- ! ción del polinomio y su derivada. ! --------------------------------------------------- ! Bloque de declaración de argumentos ! --------------------------------------------------- USE precision, WP => DP IMPLICIT NONE INTEGER, INTENT(IN) :: m ! Grado del polinomio REAL(WP), DIMENSION(0:m), INTENT(IN) :: a ! Vector de m+1 elementos conteniendo ! los coeficientes del polinomio REAL(WP), INTENT(IN) :: x0 ! Aproximación inicial a la raíz REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error absoluto INTEGER, INTENT(INOUT) :: n ! Max. iteraciones/iteraciones realizadas REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz INTEGER, INTENT(OUT) :: clave ! Clave de éxito: ! 0 : éxito ! >0 : iteraciones excedidas ! --------------------------------------------------- ! Bloque de declaración de variables locales ! --------------------------------------------------- INTEGER :: i, j REAL(WP):: xx0,b,c ! --------------------------------------------------- ! Bloque de procedimiento ! --------------------------------------------------- xx0 = x0 DO i=1,n ! ------------------------- ! Esquema de Horner ! ------------------------- b = a(m) c = a(m) DO j=m-1,1,-1 b = b*xx0+a(j) c = c*xx0+b ENDDO b = b*xx0+a(0) ! ------------------------- ! Método de Newton ! ------------------------- raiz = xx0 - b/c IF (ABS((raiz-xx0)/raiz) < tol) THEN clave = 0 n = i RETURN END IF xx0 = raiz END DO clave = 1 RETURN END SUBROUTINE birge_vieta 6
- 7. 5. Método de la secante El método de la secante procede a partir de dos aproximaciones iniciales obteniendo la apro- ximación xn+1 como la abscisa del punto de intersección del eje x con la recta secante que pasa por los puntos (xn−1, f(xn−1)) y (xn, f(xn)). La fórmula de iteración es entonces xn+1 = xn − f(xn) (xn − xn−1) f(xn) − f(xn−1) , n = 2, 3, . . . El método de la secante, si bien no converge tan rápido como Newton, tiene la gran ventaja de no requerir la derivada de la función. Eso sí, ahora se necesitan dos aproximaciones iniciales para arrancar el método. SUBROUTINE secante(f,x0,x1,n,tol,raiz,clave) ! --------------------------------------------------- ! ALGORITMO DE LA SECANTE para encontrar una solución ! de f(x)=0, siendo f una función continua, dada las ! aproximaciones iniciales x0 y x1. ! --------------------------------------------------- ! Bloque de declaración de argumentos ! --------------------------------------------------- USE precision, WP => DP IMPLICIT NONE INTERFACE FUNCTION f(x) ! Función que define la ecuación USE precision, WP => DP IMPLICIT NONE REAL(WP) :: f REAL(WP), INTENT(IN) :: x END FUNCTION f END INTERFACE REAL(WP), INTENT(IN) :: x0,x1 ! Aproximaciones iniciales a la raíz INTEGER, INTENT(INOUT) :: n ! Número máximo de iteraciones/ iteraciones realizadas REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error relativo REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz INTEGER, INTENT(OUT) :: clave ! Clave de éxito: ! 0 : éxito ! >0 : iteraciones excedidas ! --------------------------------------------------- ! Bloque de declaración de variables locales ! --------------------------------------------------- INTEGER :: i REAL(WP):: xx0, xx1, fx0, fx1 ! --------------------------------------------------- ! Bloque de procesamiento ! --------------------------------------------------- xx0 = x0 xx1 = x1 fx0 = f(x0) fx1 = f(x1) DO i= 2,n raiz = xx1 - fx1*((xx1-xx0)/(fx1-fx0)) IF (ABS((raiz-xx1)/raiz) < tol) THEN clave = 0 n = i RETURN ENDIF 7
- 8. xx0 = xx1 fx0 = fx1 xx1 = raiz fx1 = f(raiz) END DO clave = 1 RETURN END SUBROUTINE secante 6. Iteración de punto fijo El método de punto fijo requiere que se reescriba la ecuación f(x) = 0 en la forma x = φ(x) y entonces, a partir de una aproximación inicial x0, se obtiene la sucesión de aproximaciones x1, x2, ... según xn+1 = φ(xn), n = 1, 2, . . . En la siguiente implementación, es importante recordar que la función que es pasada por argumento es ahora φ(x) y no f(x), función que debe ser implementada por el usuario como una FUNCTION. SUBROUTINE punto_fijo(f,x0,n,tol,raiz,clave) ! --------------------------------------------------- ! ALGORITMO DE PUNTO FIJO o DE APROXIMACIONES SUCESIVAS ! para encontrar una solución de x=f(x) dada una ! aproximación inicial x0. ! --------------------------------------------------- ! Bloque de declaración de argumentos ! --------------------------------------------------- USE precision, WP => DP IMPLICIT NONE INTERFACE FUNCTION f(x) ! Función que define la ecuación USE precision, WP => DP IMPLICIT NONE REAL(WP) :: f REAL(WP), INTENT(IN) :: x END FUNCTION f END INTERFACE REAL(WP), INTENT(IN) :: x0 ! Aproximación inicial a la raíz INTEGER, INTENT(INOUT) :: n ! Número máximo de iteraciones/ iteraciones realizadas REAL(WP), INTENT(IN) :: tol ! Tolerancia para el error relativo REAL(WP), INTENT(OUT) :: raiz ! Aproximación a la raiz INTEGER, INTENT(OUT) :: clave ! Clave de éxito: ! 0 : éxito ! >0 : iteraciones excedidas ! --------------------------------------------------- ! Bloque de declaración de variables locales ! --------------------------------------------------- INTEGER :: i REAL(WP) :: xx0 ! --------------------------------------------------- ! Bloque de procesamiento ! --------------------------------------------------- 8
- 9. xx0 = x0 DO i=1,n raiz = f(xx0) IF (ABS((raiz-xx0)/raiz) < TOL) THEN clave = 0 n = i RETURN ENDIF xx0 = raiz END DO clave = 1 RETURN END SUBROUTINE punto_fijo 9