ApuntesFortran90 Moreira PDF

Apuntes de Fortran
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
3. Control de flujo del programa 17

3.0.1. Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.0.2. IF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.0.3. Control lógico de loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4. Entrada y salida de datos básico(input/output) 22

4.0.4. Unidades de entrada y salida . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.0.5. Formato de entrada y salida . . . . . . . . . . . . . . . . . . . . . . . . . . 24
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
2.1. Elementos básicos de un programa en Fortran

Un programa en FORTRAN tiene los siguientes elementos básicos:
Nombre del programa. El nombre del programa es en realidad opcional, pero es muy buena
idea tenerlo.
Declaraciones de variables utilizadas en el programa.
Cuerpo del programa. Comandos a ejecutar en el código. Los comandos se ejecutan en

orden de aparición. El programa siempre debe terminar con el comando end.
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.
La estructura de un comando en FORTRAN 90 tiene las siguientes propiedades:
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.
Todo lo que siga de un signo ! se considera un comentario y es ignorado por el compilador.

Los comentarios son para las personas, no para la máquina. Hacen más fácil de entender
el programa para personas que no lo escribieron, y sirven incluso para que el autor sepa lo
que hace el programa si lo vuelve a ver tiempo después.
2
CAPÍTULO 2. INSTRUCCIONES BÁSICAS 3
Es posible poner varios comandos en una línea separándolos con punto y coma “;”.
Importante: FORTRAN no distingue entre mayúsculas y minúsculas en un programa, tam-

bién ignora más de un espacio en blanco y líneas en blanco. Que se use es cuestión de estilo
personal.
2.2. Compilación y ejecución en Fortran

Los programas en FORTRAN se escriben en un editor de texto cualquiera (vi, emacs,
etcétera). Normalmente, el nombre del archivo debe llevar como sufijo .f, o .f90. A este archivo
se le llama el “código fuente". Una vez escrito el programa, este debe compilarse, es decir,
debe ser leído por un programa llamado “compilador"que lo traduce a lenguaje de máquina
y produce un nuevo archivo con el programa ejecutable. Algunos lenguajes de programación
no usan un compilador, sino un “intérprete” (por ejemplo BASIC y PERL). La diferencia es
que un interprete traduce y ejecuta línea por línea, sin nunca crear un archivo ejecutable. Un
interprete es más transparente de usar, pero mucho más lento. FORTRAN funciona siempre
con un compilador. Hay muchos compiladores diferentes, con diversas opciones al compilar (por
ejemplo, algunos prefieren el sufijo .f y otros el sufijo .f90). Existe un compilador gratuito de
FORTRAN 90 para Linux de producido por INTEL que puede bajarse de la red. La manera
estandard de compilar un programa en FORTRAN es abrir una terminal, ir al directorio que
contiene el programa, y escribir:
> gfortran nombre1.f90
donde nombre1.f90 es el nombre del programa. Es importante notar que el comando

gfotran puede variar de nombre, por ejemplo el compilador de INTEL usa el comando ifc o
ifortran. Pero siempre es posible hacer un alias (ln gfortran NuevoNombre). Al compilar el
programa se obtiene un ejecutable que tiene por default el nombre a.out. Esto puede cambiarse
haciendo:
> gfortran nombre1.f90 -o nombre2
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.
2.3. Subprograma principal

Para identificar y delimitar un subprograma principal se deben utilizar el par de instrucciones
program y end program.
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>
donde <NombreDelPrograma> es una cadena de caracteres alfanuméricos, incluído _,

de uno a 23 caracteres, sin espacios, que comienza con una letra.
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:
>emacs prog1.f90 &
Luego escribimos el código en el archivo prog1.f90:

1 program Hola_mundo
2 ! El t e x t o d e s p u é s d e l s i g n o de admiración ( ! ) e s un c o m e t a r i o
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
6 ! Instruciones ejecutables
7 print ∗ , ’ Hola Mundo ’ ! Aqui e s donde saludamos
8 end program Hola_mundo
Compilación, el segundo paso a realizar es traducir el programa a un lenguaje que el

computador pueda entenderlo (lenguaje máquina), de la siguiente manera:
>gfortran prog1.f90 -o prog1.eje
La opción -o le dice al compilador que el ejecutable se llame: prog1.eje.
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
2.4. Constantes, variables y tipos de datos

Los programas en Fortran manejan datos de dos tipos: constantes y variables. Las constantes
tienen un valor fijo, mientras que las variables se identifican con nombres y pueden cambiar de
valor durante al ejecución del programa. Constantes y variables deben tener tipos específicos que
indican al programa como almacenarlas y manejarlas.
2.4.1. Tipos de datos

Los tipos de datos permitidos son los siguientes:
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.
Límites de representación entero y real

Los límites de representación de los tipos entero y real son los siguientes:
Enteros:
−2, 147, 483, 648 ≤ i ≤ 2, 147, 483, 647
valores enteros guardados en 4 bytes.
Reales Simple Precisión:
1, 2 × 10−38 ≤ |x| ≤ 3, 4 × 1038
valores reales guardados en 4 bytes y con 8 cifras significativas.
Reales Doble Precisión:
2, 2 × 10−308 ≤ |x| ≤ 1, 8 × 10308
valores reales de doble precisión guardados en 8 bytes y con 16 cifras significativascon.
Reales quadruple Precisión: Valores reales de cuádruple precisión guardados en 16 bytes y

con 32 cifras significativas.
Los tipos implícitos

Si en un coódigo aparecen nombres que no han sido definidos por instrucciones de especifi-
cación, el tipo de la variable depende de su primera letra; así:
i, j, k, l, m, n representan variables de tipo entero.
Las otras letras variables de tipo real simple precision.
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:
implicit <tipo> (<lista_1>,<lista_2>,...,<lista_k>)
donde lista j es un caracter c1 o un intervalo de caracteres c1 − c2 , instrucción que se coloca antes

de las instrucciones declarativas de variables.
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á:
Solución Para el diseño, compilación, y ejecución del programa se debe seguir los pasos:
Diseño:
>emacs prog2.f90 &
Luego escribimos el código en el archivo prog2.f90:

1 program prueba
2 i m p l i c i t l o g i c a l ( l , u−w, z )
3 :
4 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
5 :
6 instrucciones ejecutables
7 :
8 end program prueba
Compilación:
>gfortran prog2.f90 -o prog2.eje
La opción -o le dice al compilador que el ejecutable se llame: prog2.eje.
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.
2.4.2. Declaración de variables

Toda variable debe ser declarada de manera obligatoria, cuando no corresponda a un tipo im-
plícito o bien cuando se haya recurrido a la instrucción implicit none. En general la declaración
de una variable o más variables del mismo tipo se hace siguiendo la instrucción de especificación,
bajo la siguiente sintaxis
<tipo> [,<atributo(s)>] [::] <variable(s)> [=<valor>]
Si en la instrucción de especificación aparece <atributo(s)>, o =<valor>, el uso de :: es obliga-

torio. Los atributos posibles son:
parameter, save, intent, pointer, target, allocatable, dimension,

public, private, external, intrinsic, optional.
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
integer, parameter :: nmax=100, imax=3*nmax
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.
Declaración de cadena de caracteres

La declaración de una variable de tipo character se la realiza siguiendo la siguiente sintaxis
character [(len=<longitud>)] [, <atributo(s)>] [::] <variable(s)> [=<valor>]
donde <longitud> representa el número de caracteres de la cadena, incluyendo espacios.
Ejemplos
1. Si no se especifica la longitud, la cadena tiene un solo caracter.
character inicial
2. Si no se conoce la longitud de la cadena de caracteres, se puede utilizar el comodín *, para

que la longitud sea autoajustable.
character(len=*), parameter::ciudad=’Cochabamba’, pueblo=’Sacaba’
Observamos que la cadena ciudad tiene 10 caracteres, mientras que la cadena pueblo tiene
6 caracteres.
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=<np>) [, <atributo(s)>] [::] <variable(s)> [=<valor>]
donde <np> es un entero, que toma los siguientes valores:

np = 4 para simple precisión,
np = 8 para doble precisión,
np = 16 para cuadruple precisión.
Si no se explicita la clase de real, el defecto es simple precisión.
De esta manera, las siguientes declaraciones son correctas:
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>]
Por ejemplo la declaración de una variable de tipo entero.
integer :: i=1, j=0
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.
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.4.3. Operaciones elementales en FORTRAN

Las operaciones aritméticas en FORTRAN involucran los siguientes operadores:
= Asignación. Es muy importante recalcar que este operador NO significa igualdad. En

FORTRAN, tiene sentido escribir líneas que algebraicamente son absurdas como por ejem-
plo: a = a + 1.
Esto significa tomar la variable a, sumarle 1, y asignar el resultado de nuevo a la variable
a. (a← a+1)
+ Suma (2,0 + 3,0 → 5,0).
− Resta (2,0 − 3,0 → −1,0).
∗ Multiplicación (2,0 ∗ 3,0 → 6,0).
/ División (2,0/3,0 → 0,66666667).
∗∗ Exponenciación (2,0 ∗ ∗3,0 → 8,0).
Las operaciones se realizan en el siguiente orden:
1. Términos entre paréntesis, comenzando por los de m´as adentro.
2. Exponenciación.
3. Multiplicación y división de izquierda a derecha.
4. Los cambio de signo.

5. Sumas y restas de izquierda a derecha.
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.
2.4.4. Conversión entre tipos

En FORTRAN es muy importante declarar las variables correctamente. Muchos errores co-
munes están relacionados con utilizar tipos equivocados de variables. Por ejemplo, en operaciones
entre números reales debe evitarse el utilizar variables enteras ya que fácilmente se obtendrán
valores equivocados. Supongamos que se han declarado las variables i y j como enteras, y la
variable x como real, y queremos calcular:
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
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:
Los enteros son convertidos en reales o complejos.
Los reales son convertidos en complejos.
Los reales o complejos son convertidos en la clase (kind) más alto.
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.
Así, por ejemplo:

1 program a n a l i z a r _ r e s u l t a d o
3 integer : : n=2, r
4 r e a l : : a =1.2 , b ! r e a l ( k i n d = 4 ) : : a =1.2
5 r e a l ( kind = 4 ) : : x =3.4
6 complex : : c = ( 1 . , 2 . )
7 complex ( kind = 8 ) : : z = ( 3 . , 4 . ) ! complex ( 8 ) : : z = (3. , 4 . )
8
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.
2.4.5. Operaciones de comparación

La sintaxis de la instrucción de comparación es la siguiente:
<expresión 1> <operador de comparación> <expresión 2>

Formato f90 Formato f77 Descripción

== .eq. es igual a
/= .ne. no es igual a
> .gt. es estrictamente mayor a
>= .ge. es mayor o igual a
< .lt. es estrictamente menor a
<= .le. es menor o igual a
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
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
10 end program comparar
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.
2.4.6. Operaciones lógicas

La sintáxis es:
<expresión 1> <operador de comparación> <expresión 2>
donde <expresión 1> y <expresión 2> son de tipo logical y el resultado tiene como valor,
un valor de tipo logical.
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
3 l o g i c a l : : p1 , p2 , q , p , r
4
6 r =(. not . ( p1 . o r . p2 ) ) . eqv . ( ( . not . p ) and ( . not . q ) )

7 end program s i l o
2.5. Funciones intrínsecas

Fortran cuenta con una serie de funciones matemáticas pre-definidas llamadas "funciones
intrínsecas". Una lista de algunas de ellas (no todas) es:
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
Operaciones con caracteres

Comenzamos con la instrucción de asignación, para el tipo de caracter, se tiene:
<variable>=<expresión>
donde <variable> es de tipo character[len=n] y <expresión> es de tipo character de
longitud len=m, con n y m enteros positivos. La asignación se la realiza de la siguiente manera:
Si n ≤ m, se asigna a la <variable> los n primeros caracteres, incluídos espacios, de
la <expresión>, de izquierda a derecha, eleiminando o truncando los m − n caracteres
restantes de la expresión.
Si n > m, se asigna a la <variable> de izquierda a derecha la cadena de caracteres de la
<expresión>, completando los últimos n − m caracteres de la derecha con espacios.
Operadores binarios
Para la cadena de caracteres existe los siguientes operadores binarios:
Concatenación Dado por el operador //. Por ejemplo, la expresión ’Cochabamba’//’ es

una linda ciudad.’. Da la cadena de caracteres ’Cochabamba es una linda ciudad.’.
Comparación Dados los operadores == y /=, cuyo uso es similar al caso de las expre-
siones numéricas.
Partes de cadenas de caracteres

Si la <expresión> representa una cadena de caracteres ’c1 ...ck ...cl ...cn ’ de n caracteres, con
1 ≤ k ≤ l ≤ n, las instrucciones siguientes dan:
<expresión>(k,l) ! ’ck ...cl ’

<expresión>(:,l) ! ’c1 ...ck ...cl ’
<expresión>(k,:) ! ’ck ...cl ...cn ’
Asi, por ejemplo.

1 program p a r t e s _ c h a r a c t e r
3 character ( len = 1 0 ) : : c i u d a d =’Cochabamba ’
4 character ( len = 5 ) : : c i t y , town
5
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
Otras operaciones sobre cademas de caracteres

Aparte de los operadores binarios de concatenación y comparación, y asignación de partes de
cadenas de caracteres, Fortran tiene a disposición algunas instrucciones o funciones útiles para
expresiones de tipo character cuya sintaxis es la siguiente:
<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:
Instrucción Resultado Descripción

len integer Da la longitud de la cadena de caracteres.
trim character Suprime los espacios del final de la cadena.
adjustl character Si hay espacios al inicio de la cadena, los suprime
desplazando el resto de la cadena a la izquierda
Capítulo 3
Control de flujo del programa
En general, un programa FORTRAN ejecuta las comandos en el orden en el que se escribieron,

uno a la vez. Sin embargo, frecuentemente hay situaciones en las que esto es demasiado simple
para lo que uno quiere hacer. A veces es necesario repetir una misma operación muchas veces con
ligeras variaciones, y otras veces hay operaciones que solo deben realizarse si se cumple alguna
condición. Para este tipo de situaciones existen los llamados “comandos de control del programa”
y que caen en dos tipos básicos: “loops” y condicionales.
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
de los operadores lógicos, por ejemplo:
Formato f90 Formato f77

== .eq. if(i==3) then
/= .ne. if(i/=3) then
> .gt. if(i>3) then
>= .ge. if(i>=3) then
< .lt. if(i<3) then
<= .le. if(i<=3) then
.not. .not. if(.not.q) then
.or. .or. if((i==3).or.(i==5)) then
.and. .and. if((i==3).and.(j==5)) then
El comando if puede simplificarse si solo hay un comando en su interior:

if (i==3) comando
Este comando indica que si se cumple la condición el comando indicado debe ejecutarse.
También es posible tener muchas alternativas en un condicional:
1 i f ( e x p r e s i ó n l ó g i c a 1 ) then
2 comando 1
3 e l s e i f ( e x p r e s i ó n l ó g i c a 2 ) then
4 comando 2
5 e l s e i f ( e x p r e s i ó n l ó g i c a 3 ) then
6 comando 3
7 else
8 comando 4
9 end i f
Ejemplo
Programa condicional.f90.
1 program c o n d i c i o n a l
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
7 ! Dejar un e s p a c i o para que s e vea menos f e o .

8 print ∗
9
10 ! Contar de 1 a 2 0 .
11 do i =1, 2 0 , 1
12
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
44 ! Adios end program c o n d i c i o n a l
3.0.3. Control lógico de loops

Es posible utilizar condiciones lógicas para controlar un loop. Esto se logra utilizando el
comando do while():
7 do while ( e x p r e s i ó n l ó g i c a )
8 comando 1
9 comando 2
10 ...
11 end do
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
Entrada y salida de datos

básico(input/output)
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 .
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
4.0.4. Unidades de entrada y salida

Además de utilizar el teclado y la pantalla, los datos también pueden leerse o enviarse a
un archivo. Para ello debe primero abrirse el archivo con el open que debe tener al menos dos
argumentos (puede tener varios más). El primer argumento es la “unidad” a la que se asigna la
salida o entrada de datos, que debe ser un numero entero (comúnmente se usa 10). El segundo
argumento es el nombre del archivo entre comillas (con su PATH completo si no esta en el mismo
directorio que el ejecutable). Al terminar de leer o escribir se debe cerrar el archivo con el comando
close cuyo único argumento es el número de la unidad.
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
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
16 write ( ∗ , ∗ ) ’Me l l a m o ’ , nombre

17 write ( 1 1 , ∗ ) ’Me l l a m o ’ , nombre
18
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 ’ )
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
4.0.5. Formato de entrada y salida

En ocasiones se requiere que los datos de entrada o salida estén en un formato muy específico.
El control del formato se lleva a cabo en el segundo argumento del los comandos read y write.
Existen dos posibilidades: Para formatos sencillos, el formato se coloca simplemente el formato
entre comillas y paréntesis dentro del segundo argumento, mientras que para formatos más
complicados se coloca un número entero que identifica la linea donde está el formato. Por ejemplo,
las dos opciones siguientes son equivalentes:
read ( 1 0 , ’ ( i 4 ) ’ ) m
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 )
Los diferentes opciones de formato son:

Tipo Sintaix Descripción Ejemplo Datos

integer nIw n es el número de enteros por 2i4 1234, -12
leer y w el número total de
caracteres contando con el signo
real nFw.d n es el número de variables por 2f8.3 1234.678, -234.678
leer, w el número total de
caracteres contando con el signo
y punto decimal, y d es el número
de cifras después del punto
character nAw n es el número de palabras por 2a6 ’abcdef’, ’qwerty’
leer y w el número de caracteres
espacios nX n es el número total de espacios 2x
en blanco por leer
Ejemplo
Programa seno.f90.
1 program s e n o
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)
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
Ahora vamos a cargarlo en gnuplot.

gnuplot> load ’script1.gp’
Ó estando fuera de gnuplot con:

> gnuplot script1.gp
Figura 4.1: Salida seno.dat

Capítulo 5
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.
Ejemplo Programa pitagoras.f90.

1 program p i t a
4 real : : a , b , c , hipo
5
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 )
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
Ejemplo Programa distancia.f90.

1 ! Programa p r i n c i p a l .
2 program d i s t a n c i a
5 integer i , j
6 real x , y , r
7 real radio
8
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
19 ! Calcular d i s t a n c i a a l origen llamado a funcion radio

20 r = radio (x , y)
21
22 ! Escribir a archivo .
23 write ( 1 0 , ’ ( 3 f 1 0 . 3 ) ’ ) x , y , r
24
25 end do
26 end do
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 )
35 real radio , x , y
36
37 ! Calcular distancia al origen .

38 r a d i o = s q r t ( x ∗∗2 + y ∗ ∗ 2 )
39
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.
Ejemplo Programa rutina1.f90.

1 ! Programa r u t i n a s
2 program r u t i n a s
5 integer i , j , N
6 real radio
7 real , dimension ( 1 0 , 1 0 ) : : r , x , y
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
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 )
35 real radio , x , y
36
37 ! Calcular distancia al origen .

38 r a d i o = s q r t ( x ∗∗2 + y ∗ ∗ 2 )
39
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 .
48 integer i , j ,N
49 real , dimension (N,N) : : r , x , y
50
51 ! Abrir archivo .
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
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.
Ejemplo Programa modulo1.f90.

1 ! Modulo c o n s t a n t e s .
2 module c o n s t a n t e s
3 ! D e c l a r a r p a r a m e tr os .
5 real , parameter : : p i =3.141592 , e e =2.71828
6 ! Termina modulo .
7 end module c o n s t a n t e s
8
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
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
24 ! Escribir resultados a pantalla .

25 print ∗
26 print ∗ , ’ El a r e a de un c i r c u l o de r a d i o ’ , r a d i o , ’ e s ’ , a r e a
27 print ∗
28 print ∗ , ’ El cuadrado e l numero de E u l e r e s ’ , e e 2
29 print ∗
30
31 ! Termina programa .
32 end program usamodulos

ApuntesFortran90 Moreira PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

ApuntesFortran90 Moreira PDF

Cargado por

Copyright:

Formatos disponibles

Apuntes de Fortran

3. Control de flujo del programa 17

4. Entrada y salida de datos básico(input/output) 22

2.1. Elementos básicos de un programa en Fortran

Declaraciones de variables utilizadas en el programa.

Cuerpo del programa. Comandos a ejecutar en el código. Los comandos se ejecutan en

La estructura de un comando en FORTRAN 90 tiene las siguientes propiedades:

Todo lo que siga de un signo ! se considera un comentario y es ignorado por el compilador.

Importante: FORTRAN no distingue entre mayúsculas y minúsculas en un programa, tam-

2.2. Compilación y ejecución en Fortran

> gfortran nombre1.f90

donde nombre1.f90 es el nombre del programa. Es importante notar que el comando

> gfortran nombre1.f90 -o nombre2

2.3. Subprograma principal

donde <NombreDelPrograma> es una cadena de caracteres alfanuméricos, incluído _,

>emacs prog1.f90 &

Luego escribimos el código en el archivo prog1.f90:

Compilación, el segundo paso a realizar es traducir el programa a un lenguaje que el

>gfortran prog1.f90 -o prog1.eje

La opción -o le dice al compilador que el ejecutable se llame: prog1.eje.

2.4. Constantes, variables y tipos de datos

2.4.1. Tipos de datos

Límites de representación entero y real

−2, 147, 483, 648 ≤ i ≤ 2, 147, 483, 647

valores enteros guardados en 4 bytes.

Reales Simple Precisión:

1, 2 × 10−38 ≤ |x| ≤ 3, 4 × 1038

valores reales guardados en 4 bytes y con 8 cifras significativas.

Reales Doble Precisión:

2, 2 × 10−308 ≤ |x| ≤ 1, 8 × 10308

valores reales de doble precisión guardados en 8 bytes y con 16 cifras significativascon.

Reales quadruple Precisión: Valores reales de cuádruple precisión guardados en 16 bytes y

Los tipos implícitos

i, j, k, l, m, n representan variables de tipo entero.

Las otras letras variables de tipo real simple precision.

implicit <tipo> (<lista_1>,<lista_2>,...,<lista_k>)

donde lista j es un caracter c1 o un intervalo de caracteres c1 − c2 , instrucción que se coloca antes

>emacs prog2.f90 &

Luego escribimos el código en el archivo prog2.f90:

>gfortran prog2.f90 -o prog2.eje

La opción -o le dice al compilador que el ejecutable se llame: prog2.eje.

2.4.2. Declaración de variables

<tipo> [,<atributo(s)>] [::] <variable(s)> [=<valor>]

Si en la instrucción de especificación aparece <atributo(s)>, o =<valor>, el uso de :: es obliga-

parameter, save, intent, pointer, target, allocatable, dimension,

integer, parameter :: nmax=100, imax=3*nmax

Declaración de cadena de caracteres

character [(len=<longitud>)] [, <atributo(s)>] [::] <variable(s)> [=<valor>]

donde <longitud> representa el número de caracteres de la cadena, incluyendo espacios.

2. Si no se conoce la longitud de la cadena de caracteres, se puede utilizar el comodín *, para

character(len=*), parameter::ciudad=’Cochabamba’, pueblo=’Sacaba’

real(kind=<np>) [, <atributo(s)>] [::] <variable(s)> [=<valor>]

donde <np> es un entero, que toma los siguientes valores:

Por ejemplo la declaración de una variable de tipo entero.

integer :: i=1, j=0

2.4.3. Operaciones elementales en FORTRAN

= Asignación. Es muy importante recalcar que este operador NO significa igualdad. En

+ Suma (2,0 + 3,0 → 5,0).

− Resta (2,0 − 3,0 → −1,0).

∗ Multiplicación (2,0 ∗ 3,0 → 6,0).

/ División (2,0/3,0 → 0,66666667).

∗∗ Exponenciación (2,0 ∗ ∗3,0 → 8,0).

Las operaciones se realizan en el siguiente orden: