SUBPROGRAMAS

EN FORTRAN 90

INTRODUCCION
Los programas escritos en Fortran realizados en captulos anteriores estn
estructurados en unidades programticas, en base a niveles jerrquicos. Existen
cuatro tipos de unidades programticas:
program que es la unidad programtica principal, sobre la cual hemos ido
trabajando en el transcurso de los anteriores captulos.
subroutine (subrutina) unidad programtica que contempla instrucciones
ejecutables.
function (funcin) unidad programtica que contempla instrucciones ejecutables
module unidad programtica que contempla instrucciones de declaracin de
variables, inicializacin de variables, interfaces entre funciones y subrutinas.
El programa principal, las subrutinas y funciones, son llamadas procedimientos. Un
procedimiento es interno si esta definida dentro de una unidad programtica, la
cual puede ser una unidad hospedante si se trata de un procedimiento que llama
al procedimiento interno, o bien un modulo. Un procedimiento puede ser externo, si
no esta contenida en ninguna otra unidad programtica.

Sin embargo, existe la posibilidad de tratar cada subproblema de un

problema ms grande de forma independiente. Consiste en codificar cada
subproblema en una unidad de programa5 separada llamada procedimiento
externo. Cada procedimiento externo puede ser compilado, testado y
depurado independientemente de los otros procedimientos del programa
antes de combinarlos entre s para dar lugar al programa final.
En Fortran, hay dos tipos de procedimientos externos: son los
subprogramas funciones o simplemente funciones y las subrutinas. Su
ejecucin se controla desde alguna otra unidad de programa (que puede ser
el programa principal u otro procedimiento externo). Ambos tipos de
procedimientos externos se estudian en este captulo
.

Los beneficios del

programas son:

diseo

descendente en

los

Es mucho ms fcil encontrar errores en el cdigo, sobre todo en

programas largos.
Permite usar procedimientos construidos por otros programadores.
Evita cambios indeseables en las variables del programa. Slo algunas
de ellas se transfieren entre las diferentes unidades de programa,
aquellas variables que son necesarias para realizar los clculos
previstos. Las dems variables slo son accesibles en la unidad de
programa donde se declaran quedando por lo tanto a salvo de cambios
imprevistos para el resto de las unidades de programa.
Unidad de programa es una porcin de un programa Fortran compilada
separadamente. Son unidades de programa los programas principales,
las subrutinas y los subprogramas funcin.

SUBRUTINA
Sorden jerrquico de nivel inferior
Una subrutina es subprograma de
al subprograma principal, que tiene como objetivo llevar a cabo
instrucciones ejecutables, que sern ejecutadas por un
subprograma de nivel jerrquico superior, a travs de una
instruccin que llame a la subrutina. La estructura de una
subrutina es:
subroutine <nombre>[(<argumentos (ficticios)>)]
! instrucciones de declaracin de los argumentos (ficticios)
:
! instrucciones de declaracin de los objetos locales
:
! instrucciones ejecutables
:
end subroutine <nombre>

donde los <argumentos (ficticios)>, en el caso que sean utilizados,

son los objetos, sobre los cuales la subrutina trabajara
preferentemente, estn separados por comas y pueden ser variables,
funciones, subrutinas, tableros, punteros, procedimientos de modulo.
Los objetos locales son de uso exclusivo de la subrutina y no son
utilizados por subprogramas de nivel jerrquico superior.
Las subrutinas son llamadas mediante la sentencia CALL. Seguida
por el nombre de la subrutina y posiblemente por una lista de
argumentos entre parntesis

EJEMPLO

program poli
integer::n
real,dimension(0:100)::a
real::x,p,q
print*,"Introduzca un polinomio de grado menor o
igual a 20"
print*,"Introduzca el grado del polinomio"
read*,n
print*,"Introduzca los coeficientes del polinomio"
print*,"con grado decreciente"
read*,(a(i),i=n,0,-1)
print*,"Introduzca el punto x donde desea ser
evaluado"
read*,x

call horner(n,a,x,p,q)
print*,"El valor del polinomio es p(x)= ",p
print*,"El valor de la derivada es p(x)= ",q

subroutine horner(n,a,x,p,q)
! n (entero) grado del polinomio a evaluar
! a (arreglo de a(0:n),
! coeficientes del polinomio
! x valor doble precision, donde se desea
! evaluar el polinomio
! p evaluacion del polinomio en x
! q evaluacion del polinomio derivada en x

integer::n,i
real::x,p,q
real,dimension(0:n)::a
p=a(n);
q=0.0
do i=n-1,0,-1
q=q*x+p;
p=p*x+a(i)
end do
return
end subroutine horner

Introduzca un polinomio de grado menor o igual a 20

Introduzca el grado del polinomio
4
Introduzca los coeficientes del polinomio con grado decreciente
5 -3 2 1 -1
Introduzca el punto x donde desea ser evaluado
2
El valor del polinomio es p(x)=

65.000000

El valor de la derivada es p(x)=

133.000000

Press any key to continue

USANDO LA
SENTENCIA
CONTAINS
SE CONOCEN
COMO
SUBRUTINAS
INTERNAS

program poli
integer::n
real,dimension(0:100)::a
real::x,p,q
print*,"Introduzca un polinomio de grado menor o igual
a 20"
print*,"Intrudzca el grado del polinomio"
read*,n
print*,"Introduzca los coeficientes del polinomio"
print*,"con grado decreciente"
read*,(a(i),i=n,0,-1)
print*,"Introduzca el punto x donde desea ser evaluado"
read*,x
call horner(n,a,x,p,q)
print*,"El valor del polinomio es p(x)= ",p
print*,"El valor de la derivada es p(x)= ",q
contains
subroutine horner(n,a,x,p,q)
! n (entero) grado del polinomio a evaluar
! a (arreglo de a(0:n),
! coeficientes del polinomio
! x valor doble precision, donde se desea
! evaluar el polinomio
! p evaluacion del polinomio en x
! q evaluacion del polinomio derivada en x
integer::n,i
real::x,p,q
real,dimension(0:n)::a
p=a(n);
q=0.0
do i=n-1,0,-1
q=q*x+p;
p=p*x+a(i)
end do
return
end subroutine horner
end program poli

Remarcamos que los argumentos (de uso) al llamar una subrutina, no

necesariamente deben tener los mismos nombres, lo nico que se
exige es que coincidan en posicin, tipo y clase; por ejemplo, donde
corresponde una variable entera, debe ir una expresin entera. Esto
se explica porque fortran maneja los objetos por referencia y no por
valor, como lo hacen otros lenguajes de programacin. El manejo de
objetos por referencia significa que el programa, cuando se ejecuta,
trabaja nicamente con el argumento (de uso); as por ejemplo, si i es
la variable de uso y j es la variable ficticia de una subrutina, en cuyo
cdigo fuente, se tiene la instruccin

j=j+1
lo que el programa al ejecutarse, hace realmente es

i=i+1

EJEMPLO
PROGRAM principal
INTEGER :: G,M,S
REAL::n
PRINT*,"INGRESE GRADOS,MINUTOS Y SEGUNDOS A CONVERTIR"

READ*, G,M,S !30 45 2

CALL convierte (G,M,S,n) !
PRINT*,G," grados",M, " minutos",S," segundos equivalen a"
PRINT*, n," grados decimales"
END PROGRAM principal
SUBROUTINE convierte (grados, minutos, segundos, grads)
INTEGER, INTENT(IN) :: grados, minutos, segundos
REAL, INTENT(OUT) :: grads
grads= grados + minutos/60. + segundos/3600.
RETURN
END SUBROUTINE convierte

INGRESE GRADOS, MINUTOS Y SEGUNDOS A CONVERTIR

30 45 2
30 grados

45 minutos

30.750560 grados decimales

Press any key to continue

2 segundos equivalen a

EJEMPLOS USANDO DATOS TIPO CHARACTER

PROGRAM CAMBIACARACTERES
CHARACTER(6)::VAR_CAR=" 1.2 "
INTEGER::NUM_CAR
PRINT "(2A)"," Antes de CALL, var_car = ",var_car
CALL CAMBIA_CAR(" ","0",var_car,num_car)
PRINT "(2A)"," Despues de CALL, var_car = ",var_car
PRINT "(A,I1)"," Numeros de caracteres cambiados= ",num_car
END PROGRAM CAMBIACARACTERES
SUBROUTINE
CAMBIA_CAR(si_car,nu_car,arg_car,num_car)
Character(1),intent(in)::si_car !entrada
Character(1),intent(in)::nu_car !entrada
Character(*),intent(inout)::arg_car !cambiado
integer,intent(out)::num_car !salida
Integer::I !local
Num_car=0
Do i=1,len(arg_car)
If (arg_car(i:i)==si_car) then
Arg_car(i:i)=nu_car
Num_car=num_car+1
Endif
End do
End subroutine cambia_car

Antes de CALL, var_car = 1.2

Despues de CALL, var_car = 001.20
Numeros de caracteres cambiados= 3
Press any key to continue

SUBPROGRAMAS
FUNCTION

Hay dos tipos de funciones:

Intrnsecas: todas aquellas funciones que suministra el propio

lenguaje
Definidas por el propio programador o subprogramas funcin:
procedimientos que permiten responder a necesidades particulares
del usuario, no proporcionadas por las funciones intrnsecas.

funciones intrnsecas, pueden formar parte de expresiones,

y por lo tanto, pueden aparecer en todos aquellos lugares
donde se puede usar una expresin. Su resultado es un
valor numrico, lgico, cadena de caracteres o array.

PROGRAM AREA
REAL::RADIO
PRINT*,"INGRESE RADIO DEL CIRCULO"
READ*,RADIO
PRINT*
PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO)
END PROGRAM AREA
FUNCTION AREA_CIRCULO(R) RESULT(A)
REAL::R, A
REAL,PARAMETER::PI=3.1416
A=PI*R*R
RETURN
END FUNCTION AREA_CIRCULO
INGRESE RADIO DEL CIRCULO
1
AREA DEL CIRCULO=
3.141600
Press any key to continue

PROGRAM AREA
REAL::RADIO
PRINT*,"INGRESE RADIO DEL CIRCULO"
READ*,RADIO
PRINT*
PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO)
CONTAINS
FUNCTION AREA_CIRCULO(R) RESULT(A)
REAL::R,A
REAL,PARAMETER::PI=3.1416
PROGRAM AREA
A=PI*R*R
REAL::RADIO,A1
RETURN
PRINT*,"INGRESE RADIO DEL CIRCULO"
END FUNCTION AREA_CIRCULO
READ*,RADIO
END PROGRAM AREA

PRINT*
PRINT*,"AREA DEL CIRCULO= ",AREA_CIRCULO(RADIO, A )
END PROGRAM AREA
FUNCTION AREA_CIRCULO(R, AC)
REAL::R,AC
REAL,PARAMETER::PI=3.1416
AREA_CIRCULO=PI*R*R
RETURN
END FUNCTION AREA_CIRCULO

PROGRAM conversion
REAL:: cent,x,var1,var2
print*,"ingrese temperatura en grados F"
read*,x
var1 = cent (x)
print*, x," es= ",var1
print*,"ingrese otra temperatura en grados F"
read*,x
var2 = -2.0*cent(x)+4
print*, x," es= ",var2
end program conversion
FUNCTION cent(temperatura)
REAL:: cent !declaracion del nombre de la funcion
REAL,INTENT(IN):: temperatura !declaracion del argumento formal
REAL,PARAMETER:: CTE=5./9. !parametro local a la funcion
cent= CTE*(temperatura-32.)
END FUNCTION cent

ingrese temperatura en grados F

32
32.000000 es = 0.000000E+00
ingrese otra temperatura en grados F
10
10.000000 es =
28.444450
Press any key to continue

MODULOS

La sintaxis general de un mdulo es:

MODULE nombre_modulo
[SAVE]
Declaracin e inicializacin datos
compartidos Cuerpo del mdulo
END MODULE nombre_modulo

PROGRAM principal
USE comparte_datos
IMPLICIT NONE
INTEGER :: j
PRINT*, 'v1', v1
PRINT*, 'v2',v2
v1=v1+v2
PRINT*, 'v1',v1
CALL sub
PRINT*, MATRIZ'
DO i=1,TM
PRINT*, (m(i,j),j=1,2)
END DO
END PROGRAM principal

SUBROUTINE sub
USE comparte_datos
IMPLICIT NONE
m( : , 1 ) = v1
m( : , 2 ) = v2
END SUBROUTINE sub
MODULE comparte_datos
IMPLICIT NONE
SAVE
INTEGER, PARAMETER:: TM=5
INTEGER:: i
INTEGER, DIMENSION(TM) :: v1=1,v2=(/ (i, i=10,14) /)
INTEGER, DIMENSION(TM,2) :: m
END MODULE comparte_datos

EJEMPLO DE UN PROGRAMA EN LA QUE EXISTEN VARIAS UNIDADES

PROGRAMAS QUE UTILIZAN LAS CONSTANTES RAIZ CUADRADA DE 2 Y
RAIZ CUADRADA DE 3 CUYOS VALORES RESPECTIVOS SON 1.41421 Y
1.73205 Y COMPARTEN OTRAS VARIABLES ES COORD_X, COORD_U,
COORD_Z UTILIZAMOS PARA ELLO UN MODULO

PROGRAM PAQUETES
USE COMPARTIDAS
PRINT*,"VALOR DE COORD_X "
CALL SUB1
PRINT*,COORD_X
PRINT*,"VALOR DE COORD_Y"
CALL SUB2
PRINT*,COORD_Y
PRINT*
PRINT*,"RAIZ = ",SUB3(COORD_X,COORD_Y)
END PROGRAM PAQUETES

SUBROUTINE SUB1
USE COMPARTIDAS
IMPLICIT NONE
COORD_X=RAIZ2
RETURN
END SUBROUTINE SUB1
SUBROUTINE SUB2
USE COMPARTIDAS
IMPLICIT NONE
COORD_Y=RAIZ3
RETURN
END SUBROUTINE SUB2
FUNCTION SUB3(X,Y)
REAL::X,Y
SUB3=SQRT(X**2+Y**2)
RETURN
END FUNCTION SUB3

MODULE COMPARTIDAS
IMPLICIT NONE
SAVE
REAL,PARAMETER::RAIZ2=1.41421,RAIZ3=1.73205
REAL::COORD_X,COORD_Y,COORD_Z
END MODULE COMPARTIDAS