Documentos de Académico
Documentos de Profesional
Documentos de Cultura
ApuntesFortran90 Moreira PDF
ApuntesFortran90 Moreira PDF
R. Moreira
8 de diciembre de 2008
Indice
1. Introducción 1
2. Instrucciones Básicas 2
2.1. Elementos básicos de un programa en Fortran . . . . . . . . . . . . . . . . . . . . 2
2.2. Compilación y ejecución en Fortran . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3. Subprograma principal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4. Constantes, variables y tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4.1. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4.2. Declaración de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4.3. Operaciones elementales en FORTRAN . . . . . . . . . . . . . . . . . . . 10
2.4.4. Conversión entre tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.5. Operaciones de comparación . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.6. Operaciones lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5. Funciones intrínsecas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5. Subprogramas 27
5.1. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.2. Subrutinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.3. Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
i
Capítulo 1
Introducción
En estos apuntes se presenta una breve introducción a FORTRAN 90, el lenguaje de progra-
mación de más amplio uso en el cómputo científico. El nombre FORTRAN proviene de “FORmula
TRANslator” (traductor de fórmulas), y fue desarrollado originalmente por IBM en 1954, con el
objetivo de poder escribir programas de cómputo científico en un lenguaje de alto nivel en vez
de tener que recurrir a lenguaje de máquina o ensamblador. En 1958 se presentó una segunda
versión y varias compañas comenzaron a desarrollar compiladores independientes a IBM para
usar el lenguaje en otras máquinas. El primer estandard de FORTRAN se introdujo en 1962 y se
llamó FORTRAN IV. En 1966 se presentó el primer estandard ANSI (American National Stan-
dards Institute), que se conoció como FORTRAN 66. El segundo estandard ANSI, con muchas
mejoras, se introdujo en 1977 (FORTRAN 77), y se convirtió en el estándard utilizado por la
comunidad científica por muchos años. Incluso a la fecha es común encontrar muchos programas
escritos en FORTRAN 77. FORTRAN 77 tenía una serie de desventajas. Entre ellas una estruc-
tura muy rígida adaptada al uso de tarjetas perforadas (“forma fija”), que requería que ciertas
columnas tuvieran usos específicos. Además, no permitía un uso dinámico de la memoria y no
permitía realizar operaciones entre arreglos de números. Para mejorar esta situación, en 1990 se
presentó un tercer estándard ANSI conocido como FORTRAN 90, que contenía muchas nuevas
características y permitía una programación más estructurada. Una serie de cambios menores
se presentaron en 1995 (FORTRAN 95), y actualmente se trabaja en un nuevo estándard ANSI
(FORTRAN 2003). El día de hoy la mayor parte de los programas en FORTRAN siguen el es-
tándard de FORTRAN 90, pero aún existe un número importante de aplicaciones de FORTRAN
77. FORTRAN esta específicamente diseñado para el cómputo científico, y no es particularmente
bueno para otro tipo de aplicaciones (control, administración, manejo de documentos, etc). Para
estas aplicaciones otros lenguajes somo C, JAVA o PERL son más adecuados. En la actualidad,
la mayor parte del cómputo científico de alto rendimiento a nivel internacional se lleva a cabo en
FORTRAN (FORTRAN esta muy lejos de ser obsoleto), aunque los lenguajes C, C++, y JAVA
han ganando cierta popularidad recientemente.
1
Capítulo 2
Instrucciones Básicas
Nombre del programa. El nombre del programa es en realidad opcional, pero es muy buena
idea tenerlo.
Subprogramas. El cuerpo del programa puede llamar a subprogramas que realicen tareas
específicas. Es buena práctica de programación separar un programa en bloques y poner
cada bloque en diferentes subprogramas. De hecho, para programas largos es buena idea
tener cada subprograma en archivos separados.
Los comandos se escriben en líneas de a lo más 132 caracteres (aunque algunos compiladores
aceptan líneas más largas).
Espacios en blanco al principio de una línea se ignoran. Esto ayuda a mejorar visualmente
la estructura del programa. Hay que recordar que no solo la máquina va a leer el programa,
sino también seres humanos (por lo menos el autor), por lo que una estructura visualmente
clara en importante.
Un signo & al final de una línea indica que el comando continua en la línea siguiente.
2
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 3
Es posible poner varios comandos en una línea separándolos con punto y coma “;”.
La opción -o le dice al compilador que el ejecutable debe llamarse nombre2. Para cor-
rer el programa se escribe simplemente
> ./nombre2
donde se usa ./ para indicar a Linux que debe buscar el ejecutable en el directorio actu-
al. Para programas que están contenidos en varios archivos, hay una etapa más. El compilador
primero genera “archivos objeto" con sufijo .o que contienen la traducción a lenguaje de máquina
de cada archivo individual. Después se hace una liga (link) entre los diversos archivos objeto
para construir el ejecutable.
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 4
1 program <NombreDelPrograma>
2
3 ! I n s t r u c c i o n e s no e j e c u t a b l e s
4 .
5 .
6 .
7 ! Instrucciones ejecutables
8 .
9 .
10 .
11 end program <NombreDelPrograma>
Ejemplo Diseñe un programa en código fuente Fortran que escriba en pantalla “Hola Mundo”.
Solución Para el diseño, compilación, y ejecución del programa se debe seguir los pasos:
Diseño, el primer paso a realizar es elegir un directorio específico (para ordenar nuestros
archivos) y escribir el código fuente en un editor de texto, como por ejemplo emacs, de la
siguiente manera:
6 ! Instruciones ejecutables
7 print ∗ , ’ Hola Mundo ’ ! Aqui e s donde saludamos
8 end program Hola_mundo
Ejecución, el tercer y último paso es correr el programa con la ejecución del archivo
ejecutable:
>./prog1.eje
La opción ./ indica a Linux que debe buscar el ejecutable en el directorio actual. Finalmente
en pantalla de debe observarse la instrucción ejecutada por el computador:
Hola Mundo
logical Las variables lógicas solo pueden tener dos valores: .true. (verdadero) y .false. (falso).
integer Números enteros, que pueden tomar todos los valores positivos o negativos entre límites que
dependen del computador y el compilador. Se indican como números sin punto decimal: 1,
2, -3, 25, etc.
character Cadena de uno o varios caracteres. Por ejemplo: ‘fortran’, ‘Hola como estas’, “Maria’s
pencil”.
real Números reales que pueden tomar valores positivos o negativos entre límites que dependen
de la computadora y el compilador. Por ejemplo: 1.23e-6, 1.1234, etc.
complex Números complejos compuesto de una parte real y una parte imaginaria, ambas partes de
tipo real. Por ejemplo: (1.2, 2.3e03), (1.12, 23.5), etc.
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 6
Enteros:
El carácter implícito de las variables de las variables puede ser modificado, a través de la
instrucción implicit cuya sintaxis es la siguiente:
Ejemplo Se desea que todas las variables que comienzan con la letra l, las letras entre la u y w,
así como la letra z, sean de tipo logical. La instrucción será:
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 7
Solución Para el diseño, compilación, y ejecución del programa se debe seguir los pasos:
Diseño:
Compilación:
Ejecución:
>./prog2.eje
La utilización de tipos implícitos puede dar lugar a errores no detectados por el compilador
y que son dificiles de detectarlos. Por consiguiente, mejor es evitar, en lo posible, la regla de
la definición implícita y definir explícitamente todas las variables a ser utilizadas, colocando
la instrucción de especificación
implicit none
antes de especificar y declarar cada una de las variables del programa, con lo que cualquier
variable que no haya sido declarada será detectada y dará error en la compilación del código
fuente.
Declaración de constantes
Cuando se quiere o requiere que una variable tome únicamente un valor durante la ejecución
del programa y no pueda ser suceptible de cambio alguno, se utiliza el atributo parameter y la
o las variables especificadas con el valor asignado. Por ejemplo
Viendo el ejemplo, la segunda variable imax ha sido declarada en función de la primera variable
nmax. Esto es posible, siempre y cuando las variables que definan una variable con atributo
parameter, deben tener el atributo parameter, estar definidas y las operaciones, que intervienen
en la expresión de definición, ser elementales, por ejemplo aritméticas. La especificación de una
variable constante es aconsejada si: la variable no cambia de valor durante la ejecución del
programa, para hacer más lisible el código (por ejemplo dos_pi y sobre todo para poder modificar
más facilmente el código fuente.
Ejemplos
1. Si no se especifica la longitud, la cadena tiene un solo caracter.
character inicial
Observamos que la cadena ciudad tiene 10 caracteres, mientras que la cadena pueblo tiene
6 caracteres.
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 9
Tipos de reales
La mayoría de los compiladores Fortran trabajan con dos tipos de real: el primero, simple pre-
cisión y el segundo tipo, doble precisión. Existen algunos compiladores, como ifort, que trabajan
con cuadruple precisión.
La sintaxis para definir el tipo de real es la siguiente:
real(kind=4)::x=1.e0
real(kind=8)::y=-2.d-5
real(kind=16)::qx=-3.q-100
Como puede observarse la letra e es el identificador de notación científica para simple precisión,
d para doble precisión y q para cuadruple precisión.
Declaración de enteros
integer [, <atributo(s)>] [::] <variable(s)> [=<valor>]
Tipos de complejo
Complex es un tipo derivado del tipo real; consiguientemente hay complex simple precisión,
complex doble precisión y algunos compiladores acceptan complex cuadruple precisión. Las
declaraciones, utilizando kind, serán por lo tanto:
integer, parameter:: np=8
complex(kind=4)::c=(1.e0,0.)
complex(kind=8)::z=(-2.d-5,1.d0)
complex(kind=16)::qz=(-3.q100,-1.q-10)
complex(kind=np)::z_np=(1._np,-1._np)
Por lo tanto, las observaciones, hechas para real, son válidas para complex.
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 10
Ejemplo
Con algunos ejemplos de la declaración de tipos de varables, se tiene el siguiente ejemplo.
1 program v a l o r e s
2 i m p l i c i t none
3 integer , parameter : : nmax=100 , imax=3∗nmax
4 character i n i c i a l
5 character ( len =∗) , parameter : : c i u d a d =’Cochabamba ’ , p u e b l o =’ Sacaba ’
6 r e a l ( kind = 4 ) : : x=1. e0
7 r e a l ( kind = 8 ) : : y=−2.d−5
8 integer : : i =1, j =0
9 complex ( 4 ) : : c =(1. e0 , 0 . )
10 complex ( 8 ) : : z =(−2.d−5, 1 . d0 )
11
12
13 end program v a l o r e s
2. Exponenciación.
IMPORTANTE: Igual que cuando uno hace operaciones a mano, es mucho más difícil
dividir que multiplicar, por lo que resulta mucho más lento. A FORTRAN le toma mucho más
tiempo calcular 5.0/2.0 que calcular 5.0*0.5. Siempre que sea posible se deben evitar las divisiones
para tener un código más eficiente.
x = i/j
Si tenemos i=10 y j=4 el resultado será 2 y no 2.5 como uno podría esperar. Esto se debe a que la
división entre números enteros siempre se considera un entero. Para evitar este tipo de errores es
importante convertir un tipo de variables a otras. Esto puede lograrse con los comandos: int(),
nint(), real(), dble().
Los comandos real() y dble() convierten la cantidad entre paréntesis a una variable real
o de doble precisión, respectivamente.
Los comandos int() y nint() convierten la cantidad entre paréntesis a un número entero,
la diferencia está en que int() simplemente trunca el número, mientras que nint() lo
reduce al entero más cercano.
Ejemplo
Programa convertir.f90.
1 program c o n v e r t i r
2
3 print ∗ , 10/4
4 print ∗ , 10.0/4.0
5 print ∗ , real (10)/ real (4)
6 print ∗ , real (10/4)
7 print ∗ , dble (10)/ dble (4)
8 print ∗ , int (10.7)
9 print ∗ , nint (10.7)
10 print ∗ , i n t ( −3.7)
11 print ∗ , n i n t ( −3.7)
12
13 end program c o n v e r t i r
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 12
En caso de operaciones aritméticas entre objetos de tipo o clases de tipo diferentes, la com-
putadora convierte los operandos a valores del mismo tipo y misma clase de tipo, siguiendo las
siguientes reglas:
En la asignación de valores (=), la parte derecha es evaluada en el tipo y clase que corres-
ponde, luego es convertida al tipo y clase de la variable del lado izquierdo.
10 r =(x ∗ ( c ∗∗n ) ) / z
11 b=n+z
12
13 print ∗ , r
14 print ∗ , n∗∗ c
15 print ∗ , x ∗ ( n∗∗ c )
16 print ∗ , ( x ∗ ( n∗∗ c ) ) / z
17 end program analizar_resultado
Para asignar un valor a la variable r, siguiendo el orden establecido por los paréntesis, la
computadora convierte n en tipo complex, evalua (n**c) en complex; luego convierte x en com-
plex, evalua x*(c**n) en complex; después convierte x*(c**n) en complex(kind=8) y evalua
(x*(n**c))/z en complex(kind=8); por último, para asignar el valor a la variable a, convierte
(x*(n**c))/z en real. Dejamos como ejercicio, el flujo de conversión para la expresión b=n+z.
Donde la <expresión 1> y <expresión 2> son expresiones de tipo numérico (integer, real,
complex) y tienen como resultado un valor de tipo lógico (.true., o .false.).
Para expresiones de tipo complex como operandos, solamente son válidos los operadores de
comparación == y /=.
Las operaciones de comparación se evaluan después de evaluar las expresiones aritméticas o
numéricas.
Ejemplo
Programa comparar.f90.
1 program comparar
2 i m p l i c i t none
3 logical : : l
4 r e a l : : a =1.2 , b =2.0 , c =0.5
5 integer : : n=2, m=3
6
8 l=n∗∗m<a+b∗∗ c
9
Las instrucciones listadas, tienen como flujo de conversión y orden de operaciones: la computdora
evalua la expresión n**m, la convierte en tipo real, evalua la expresión a+b**c que es de tipo
real, luego aplica el operador de comparación <, cuyo resultado es de tipo logical.
donde <expresión 1> y <expresión 2> son de tipo logical y el resultado tiene como valor,
un valor de tipo logical.
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 14
Operador Significado
.not. No (operador unario, un solo operando)
.and. y
.or. o
.eqv. equivalente
.neqv. no equivalente
Ejemplo
Programa silogismo.f90.
1 program s i l o
2 i m p l i c i t none
3 l o g i c a l : : p1 , p2 , q , p , r
4
Fortran 90 Descripción
sqrt(x ) Raíz cuadrada de x
abs(x ) Valor absoluto de x
sin(x ) Seno de x
cos(x ) Coseno x
tan(x ) Tangente de x
asin(x ) Arco-seno de x
acos(x ) Arco-coseno de x
atan(x ) Arco-tangente de x
exp(x ) Exponencial de x (ex )
log(x ) Logaritmo natural de x
log10(x ) Logaritmo en base 10 de x
max(x,y) Máximo entre x y y
min(x,y) Mínimo entre x y y
int(x ) Parte entera de un real x
fraccion(x ) Parte fraccional de un real x
real(z ) Parte real del complejo z
aimag(z ) Parte imaginaria del complejo z
conjg(z ) Conjugado del complejo z
cmplx(x,y) Convierte dos reales x, y a complejo
mod(x,y) Resto o residuo de la división de x con y
Operadores binarios
Para la cadena de caracteres existe los siguientes operadores binarios:
7 town=’Cochabamba ’ ( 6 , : ) ! town=’bamba ’
8 c i t y=c i u d a d ( : , 5 ) ! c i t y =’Cocha ’
9 end program p a r t e s _ c h a r a c t e r
<instrucción>=<expresión>
donde <expresión> es una expresión cuyo valor es de tipo character e <instrucción> corre-
sponde a una de las instrucciones de la tabla:
3.0.1. Loops
Un “loop” es un conjunto de instrucciones que deben realizarse muchas veces y tiene la forma
estandard:
7 do i=i n i c i o , f i n , i n c r e m e n t o
8 comando 1
9 comando 2
10 comando 3
11 ...
12 end do
Todos los comandos que están contenidos entre la linea do i=... y la linea end do se repiten
varias veces, dependiendo de los valores de inicio, fin, incremento que deben ser enteros.
La primera vez, la variable i toma el valor inicio. Al terminar, el valor de i se incrementa en
incremento, si el valor final es mayor que fin el loop ya no se ejecuta de nuevo y el programa
continua en el comando que siga después de end do, de lo contrario se vuelven a ejecutar los
comandos dentro del loop hasta que se obtenga i>fin. Nota: El indentar los comandos dentro
del loop no es necesario (FORTRAN ignora los espacios extra), pero es una buena idea pues hace
más fácil identificar visualmente donde comienza y termina el loop.
Ejemplo
Programa fibonacci.f90.
17
CAPÍTULO 3. CONTROL DE FLUJO DEL PROGRAMA 18
1 program f i b o n a c c i
2 ! E s t e programa c a l c u l a l o s numeros de l a s e r i e
3 ! de f i b o n a c c i h a s t a nmax . i m p l i c i t none i n t e g e r i , nmax
4 integer jnew , j o l d , aux
5
6 ! Poner un l i m i t e .
7 nmax = 10
8
9 ! I n i c i a l i z a r ( jnew , j o l d ) .
10 jnew = 1 ; j o l d = 1
11
12 ! Iniciar loop .
13 print ∗
14 do i =1,nmax , 1
15 ! Imprimir e l e m e n t o i de l a s e r i e .
16 print ∗ , ’ Elemento ’ , i , ’ de l a s e r i e de F i b o n a c c i : ’ , jnew
17 print ∗
18 ! C a l c u l a r nuevo e l e m e n t o de l a s e r i e .
19 aux = jnew
20 jnew = jnew + j o l d
21 j o l d = aux
22 end do
23
24 end program f i b o n a c c i
3.0.2. IF
En ocasiones uno desea que una parte del programa solo sea ejecutada si cierta condición
específica se satisface. Esto se logra utilizando los “condicionales”, que en FORTRAN se controlan
con el comando IF. La estructura de este comando es la siguiente:
7 i f ( e x p r e s i ó n l ó g i c a ) then
8 comando 1
9 comando 2
10 ...
11 else
12 comando A
13 comando B
14 ...
15 end i f
Al ejecutar esto, el programa verifica si la expresión lógica entre paréntesis después del if es
verdadera. De serlo, se ejecutan los comandos siguientes. De ser falsa, se ejecutan los comandos
después del else (nótese que el [else] es opcional). La expresión lógica puede utilizar cualquiera
CAPÍTULO 3. CONTROL DE FLUJO DEL PROGRAMA 19
Ejemplo
Programa condicional.f90.
1 program c o n d i c i o n a l
2 i m p l i c i t none
3 ! Declaramos una v a r i a b l e l o g i c a y una e n t e r a .
4 logical : : q
5 integer : : i
6
10 ! Contar de 1 a 2 0 .
11 do i =1, 2 0 , 1
12
CAPÍTULO 3. CONTROL DE FLUJO DEL PROGRAMA 20
13 ! Estamos a b a j o de 10?
14 i f ( i <=9) then
15 print ∗ , ’No hemos l l e g a d o a l 1 0 , vamos en ’ , i
16
17 ! Estamos j u s t o en 10?
18 e l s e i f ( i ==10) then
19 print ∗ , ’ Vamos j u s t o en 1 0 ’
20
21 ! Estamos a b a j o de 16?
22 e l s e i f ( i <16) then
23 print ∗ , ’Ya nos pasamos d e l 1 0 , vamos en ’ , i
24
25 ! Nada de l o a n t e r i o r .
26 e l s e print ∗ , ’Ya pasamos d e l 1 5 , vamos en ’ , i
27 end i f
28
29 ! En c a s o de e s t a r en 13 a v i s a r .
30 i f ( i ==13)
31 print ∗ , ’ Por c i e r t o , ahora vamos en 1 3 ’
32
33 ! D e f i n i r l a v a r i a b l e l o g i c a ‘ ‘ q ’ ’ . Sera v e r d a d e r a
34 ! s i no estamos en 1 9 .
35 q = ( i /= 1 9 )
36
37 ! Ahora a v i s a r s i e m p r e que ‘ ‘ q ’ ’ s e a f a l s a .
38 i f ( . not . f l a g )
39 print ∗ , ’Y ahora estamos en 1 9 ’
40
41 ! Ya terminamos de c o n t a r
42 end do
43
En este caso no se cuenta con una variable entera como en el caso estándard, sino que el loop
se ejecuta una y otra vez mientras la expresión lógica sea verdadera. El loop se detiene una vez
que dicha expresión es falsa. Por ejemplo, el siguiente código actúa de la misma forma que un
loop estándard de 1 a 20:
7 i = 1
8 do while ( i <=20)
9 i = i + 1
10 end do
CUIDADO: Con este tipo de loops se corre el riesgo de caer en un ciclo eterno, donde la condi-
ción lógica nunca deja de satisfacerse y la máquina sigue ejecutando el loop para siempre. Cuando
se trabaja en una terminal uno nota esto fácilmente si el código continua mucho tiempo más del
que esperábamos sin hacer aparentemente nada. En ese caso siempre se puede detener al código
tecleando [CTRL C]. Pero cuando uno esta corriendo en una cola en una super-computadora se
corre el riesgo de terminarse la cuota que debería haber durado un año de una sola vez, y peor
aún, los encargados del sistema pueden decidir retirar los privilegios de trabajar en esa máquina
ante semejante desperdicio de recursos de cómputo y falta de cuidado.
Capítulo 4
En la mayoría de los códigos científicos es necesario dar datos desde fuera y sacar datos hacia
afuera. Por defecto, la entrada de datos es desde el teclado y la salida es a la pantalla. La entrada
y salida de datos se manejan con los comandos:
read(,)
write(,)
Ambos comandos tienen dos argumentos, el primero de los cuales indica la “unida” de entrada
o salida, y el segundo el formato en el que están los datos. La versión mas simple es:
read(*,*)
write(*,*)
Aquí, el primer asterisco indica entrada o salida estándard (teclado y pantalla respectiva-
mente), y el segundo formato libre. El comando write(*,*) puede substituirse por la forma
equivalente print* seguido de una coma.
Ejemplo
Programa Hola_nombre.f90.
1 program h o l a
2 ! Declarar v a r i a b l e s .
3 i m p l i c i t none
4 character ( 2 0 ) : : nombre
5
6 ! P r e g u n t a r como t e l l a m a s .
7 print ∗
8 write ( ∗ , ∗ ) ’Como t e l l a m a s ? ’
9 print ∗
10
11 ! Leer r e s p u e s t a d e s d e e l t e c l a d o .
12 read ( ∗ , ∗ ) nombre
22
CAPÍTULO 4. ENTRADA Y SALIDA DE DATOS BÁSICO(INPUT/OUTPUT) 23
13
14 ! Saludar .
15 print ∗
16 write ( ∗ , ∗ ) ’ Hola ’ , nombre
17 print ∗
18
19 end program h o l a
Ejemplo
Programa archivo.f90. Para este ejemplo es necesario crear primero un archivo de datos
llamado “entrada.dat” que contenga solo una linea con: juan,25,masculino.
1 program a r c h i v o
2 i m p l i c i t none
3 integer edad
4 character ( 2 0 ) : : nombre , s e x o
5
6 ! A b r i r e l a r c h i v o de e n t r a d a
7 open ( 1 0 , f i l e =’ e n t r a d a . dat ’ )
8
9 ! Leer d a t o s
10 read ( 1 0 , ∗ ) nombre , edad , s e x o
11
12 ! Cerrar a r c h i v o de e n t r a d a
13 close (10)
14
15
19
20 ! A b r i r a r c h i v o de s a l i d a
21 open ( 1 2 , f i l e =’ f e r c h o . rbd ’ )
CAPÍTULO 4. ENTRADA Y SALIDA DE DATOS BÁSICO(INPUT/OUTPUT) 24
22
23 ! Escribir datos
24 write ( 1 2 , ∗ ) ’Me l l a m o ’ , nombre
25 write ( 1 2 , ∗ ) ’ Tengo ’ , edad , ’ años ’
26 write ( 1 2 , ∗ ) ’ Mi s e x o e s ’ , s e x o
27 ! Cerrar a r c h i v o s a l i d a
28 close (12)
29
30 end program a r c h i v o
read ( 1 0 , 1 0 0 ) m
100 format ( i 4 )
En ambos casos se indica al código que debe leer un número entero de a lo más 4 dígitos de
longitud “i4”. La ventaja del segundo método es que se puede usar el mismo formato en más de
un comando:
read ( 1 0 , 1 0 0 ) i
read ( 1 0 , 1 0 0 ) j
read ( 1 0 , 1 0 0 ) k
100 format ( i 4 )
Ejemplo
Programa seno.f90.
1 program s e n o
2 ! Declarar v a r i a b l e s .
3 i m p l i c i t none
4 integer i
5 real x , s , pi
6
7 ! Calcular pi .
8 p i = a c o s ( −1.0) ! c o s ( p i )=−1
9
10 ! A b r i r a r c h i v o de s a l i d a .
11 open ( 1 0 , f i l e =’ s e n o . dat ’ )
12
13 ! Loop d e s d e 0 h a s t a 2∗ p i en 100 p a s o s .
14 do i =0 ,100 , 1
15
16 ! C a l c u l a r x e n t r e 0 y 2∗ pi , y su seno .
17 x = 2.0∗ pi ∗ real ( i )/100.0
18 s = sin (x)
19
20 ! Escribir al archivo .
21 write ( 1 0 , ’ ( 2 f 1 0 . 4 ) ’ ) x , s
22
23 end do
24
25 ! Cerrar a r c h i v o .
26 close (10)
CAPÍTULO 4. ENTRADA Y SALIDA DE DATOS BÁSICO(INPUT/OUTPUT) 26
27 end program s e n o
Ahora el archivo de salida seno.dat podemos graficar con gnuplot, desde un archivo de
texto, editandolo desde nuestro editor de texto favorito. Para este fin tenemos que crear un
archivo llamado por ejemplo script1.gp.
1 reset
2 set t i t l e ’ Seno ( x ) ’
3 set xlabel ’ x ’
4 set ylabel ’ s e n o ( x ) ’
5 set grid
6 plot ’ s e n o . dat ’
7 pause 3
8 exit
Subprogramas
En muchas ocasiones existen tareas que se deben realizar muchas veces durante la ejecución
de un código, por lo que resulta conveniente que sean subprogramas en si mismos. La existencia
de subprogramas también hace que un código sea más modular, y permite que diferentes personas
programen diferentes partes de un mismo código. Los diversos subprogramas pueden ser parte de
un mismo archivo, o estar en archivos separados que se unen durante el proceso de compilación.
Si están en un mismo archivo, deben aparecer después de la linea que termina el programa
principal. En FORTRAN 90 hay tres tipos básicos de subprogramas: funciones, subrutinas y
módulos. Consideraremos cada uno de ellos por separado.
5.1. Funciones
Así como existen funciones intrínsecas en FORTRAN (sin, cos, etc.), también es posible
definir funciones nuevas de una o más variables. El objetivo de una función es obtener un
número a partir de los argumentos. Al igual que el programa principal, una función comienza
por su nombre function nombre. Al final de la función deben aparecer los comandos return
seguido de end function nombre, esto regresa el control al programa principal. La función es
una unidad autónoma, por lo que debe declarar todas las variables que utiliza, incluyendo el
nombre de la función y los argumentos. Es muy importante que los argumentos de la función
sean del mismo tipo cuando se llama la función y en la función misma, de otra forma habrá
errores al ejecutar el código. El nombre de la función debe declarase en el programa principal y
cualquier subprograma que la llame.
6 write ( ∗ , ∗ ) ’ I n g r e s e a y b : ’
7 read ( ∗ , ∗ ) a , b
27
CAPÍTULO 5. SUBPROGRAMAS 28
9 ! Calculamos l a h i p o t e n u s a con l a f u n c i ó n h i p o
10 c=h i p o ( a , b )
11 write ( ∗ , ∗ ) c
12 end program p i t a
13
14 ! Creamos l a f u n c i ó n h i p o
15 function h i p o ( x , y )
16 i m p l i c i t none
17 real : : x , y , hipo
18
19 ! Calculamos l a h i p o t e n u s a
20 h i p o=s q r t ( x∗∗2+y ∗ ∗ 2 )
21
22 ! Retornamos e l c o n t r o l a l programa p r i n c i p a l
23 return
24 end function h i p o
9 ! A b r i r a r c h i v o de s a l i d a .
10 open ( 1 0 , f i l e =’ r a d i o . dat ’ )
11
12 ! Loop en dos d i m e n s i o n e s .
13 do i =1, 1 0 , 1
14 do j =1 ,10
15 ! Coordenadas en e l p l a n o .
16 x = real ( i )
17 y = real ( j )
18
22 ! Escribir a archivo .
23 write ( 1 0 , ’ ( 3 f 1 0 . 3 ) ’ ) x , y , r
24
25 end do
CAPÍTULO 5. SUBPROGRAMAS 29
26 end do
27 ! Cerrar a r c h i v o .
28 close (10)
29 end program d i s t a n c i a
30
31 ! Funcion r a d i o .
32 function r a d i o ( x , y )
33 ! Declarar v a r i a b l e s .
34 i m p l i c i t none
35 real radio , x , y
36
40 ! Terminar f u n c i o n .
41 return
42 end function r a d i o
5.2. Subrutinas
Una subrutina es similar a una función, pero más complicada, de la que no solo se espera un
número, sino toda una secuencia de operaciones que pueden requerir regresar muchos números
al programa principal (o ninguno). Las subrutinas se llaman usando el comando call nombre.
Igual que las funciones, las subrutinas comienzan por su nombre subroutine nombre y terminar
con los comandos return y end subroutine nombre. También son unidades autónomas que
deben declarar todas las variables que utilizan, incluyendo a sus argumentos. A diferencia de las
funciones, el nombre de una subrutina no tiene un tipo (el nombre de las funciones si tiene un
tipo pues corresponde al valor de regreso). Una característica importante de las subrutinas es que
cuando se pasa un arreglo como uno de sus argumentos, no es necesario dar el tamaño. Se puede
pasar el tamaño como un argumento, digamos N, y simplemente declarar el arreglo como real,
dimension(N) :: nombre. Algo similar sucede con los variable de tipo character que se pueden
declarar con dimensión indeterminada usando * cuando son parte de los argumentos de la
subrutina, de manera que heredan el tamaño que tenían el en programa que llamo a la subrutina.
9 ! A b r i r a r c h i v o de s a l i d a .
10 open ( 1 0 , f i l e =’ r a d i o . dat ’ )
11 ! Loop en dos d i m e n s i o n e s .
12 N = 10
13 do i =1, N, 1
14 do j =1, N
15 ! Coordenadas en e l p l a n o .
16 x ( i , j ) = real ( i )
17 y ( i , j ) = real ( j )
18 ! Calcular d i s t a n c i a a l origen llamado a funcion radio .
19 r ( i , j ) = radio (x( i , j ) , y( i , j ))
20 end do
21 end do
22
23 ! Llamar s u b r u t i n a e s c r i b i r .
24 c a l l e s c r i b i r (N, r , x , y )
25
26 ! Cerrar a r c h i v o .
27 close (10)
28
29 end program r u t i n a s
30
31 ! Funcion r a d i o .
32 function r a d i o ( x , y )
33 ! Declarar v a r i a b l e s .
34 i m p l i c i t none
35 real radio , x , y
36
40 ! Terminar f u n c i o n .
41 return
42 end function r a d i o
43
44 ! Subrutina e s c r i b i r .
45 subroutine e s c r i b i r (N, r , x , y )
46 ! Declarar v a r i a b l e s y a r r e g l o s .
47 i m p l i c i t none
48 integer i , j ,N
49 real , dimension (N,N) : : r , x , y
50
51 ! Abrir archivo .
CAPÍTULO 5. SUBPROGRAMAS 31
52 open ( 1 0 , f i l e =’ d i s t a n c i a 2 . dat ’ )
53 ! Loop de dos d i m e n s i o n e s para e s c r i b i r a a r c h i v o .
54 do i =1,N
55 do j =1,N
56 write ( 1 0 , ’ ( 3 f 1 0 . 3 ) ’ )
57 x( i , j ) ,y( i , j ) , r ( i , j )
58 end do
59 end do
60
61 ! Cerrar a r c h i v o .
62 close (10)
63 ! Terminar s u b r u t i n a .
64 return
65 end subroutine e s c r i b i r
5.3. Módulos
El último tipo de subprogramas son los módulos que solo existen a partir de FORTRAN 90.
Los módulos sirven básicamente para declarar variables que se usan en muchos subprogramas, o
para agrupar muchos subprogramas en una sola unidad. Los módulos comienzan por su nombre
module nombre y terminan con end module nombre (en los módulos no se utiliza el comando
return). A diferencia de las funciones y subrutinas, si el módulo está en el mismo archivo
que el programa principal, debe estar antes que este. Cualquier subprograma que haga uso del
módulo debe hacerlo mediante el comando use nombre inmediatamente después del nombre del
subprograma.
El uso más común de los módulos es para declarar variables que van a ser utilizadas por
muchos subprogramas.
9 ! Programa p r i n c i p a l
10 program usamodulos
11 ! Usar modulo c o n s t a n t e s .
12 use c o n s t a n t e s
13
CAPÍTULO 5. SUBPROGRAMAS 32
14 ! Declarar v a r i a b l e s .
15 i m p l i c i t none
16 real radio , area
17 real ee2
18
19 ! D e f i n i r r a d i o y c a l c u l a r area y ee2 .
20 radio = 10.0
21 a r e a = p i ∗ r a d i o ∗∗2
22 e e 2 = e e ∗∗2
23
31 ! Termina programa .
32 end program usamodulos