M. C.

Bulmaro Quiroz Hernández

FORTRAN
FORTRAN: El FORmula TRANstator
(traductor de fórmulas).
Sus proposiciones se asemejan a
expresiones algebraicas.
 Conceptos y definiciones básicas

INSTRUCCIÓN: Orden o acción clara y precisa.

ALGORITMO : Descripción precisa de una sucesión de

instrucciones para realizar un trabajo en un número finito
de pasos.

PROGRAMA : Es la codificación de un algoritmo en algún

lenguaje.

PROCESO: Ejecución de una o varias instrucciones en

forma secuencial.

VARIABLE : Es un lugar de memoria donde se almacena

un dato que puede ir cambiando. Tiene los siguientes
atributos: nombre y tipo de dato. El tipo de dato delimita
las operaciones que podrán realizarse con la variable.
 Reglas para definir nombres de
variables:
1.- El primer carácter del nombre debe ser
una letra del alfabeto.
2.- Para formar un nombre de variable sólo
pueden usarse letras mayúsculas (A-Z) y
dígitos (0-9).
El programador en FORTRAN, debe aprender a
manejar varios tipos diferentes de datos.
• Un número entero
• Un número real
Por convección:
Variable Entera: comienzan con I, J, K, L,
M o N.
Variable Real: Comienzan con una letra
diferente (A-H o O-Z)
Estructura de Programas
La estructura general en la pantalla sería la siguiente:
Existen 5 zonas diferenciadas:
En la 1ª columna se escribe una C en el caso de que queramos introducir
una línea de comentarios. En caso contrario, esta línea estará siempre en
blanco.

Las columnas 2 a 5 sirven para especificar etiquetas. Las etiquetas son

nombres que se pueden dar a las líneas para referenciarlas posteriormente.

La columna 6 sirve para introducir un caracter que indique al compilador

que la línea anterior continúa en ésta. Esto es necesario cuando una línea
supera en longitud la columna 72. En este caso, podemos continuarla en la
línea siguiente colocando aquí un caracter.
Ejemplo:
c La siguiente sentencia esta en dos líneas
físicas
area = 3.14159265358979
% *r*r
Cualquier carácter puede ser usado en vez del signo "+" como carácter de
continuación. Se considera un buen estilo de programación usar el signo
más, o números (2 para la segunda línea, 3 para la tercera y así
sucesivamente).

Las columnas 7 a 72 definen la zona en la cual se sitúa el código

FORTRAN. Aquí se escriben los programas.
Mas allá de la columna 72 el compilador ignora el contenido.
Todo programa en FORTRAN tiene siguiente estructura:
program nombre_programa
sentencia 1
sentencia 2
...
end
Las sentencias pueden ser:
Declaraciones de variables.
Definiciones de constantes.
Instrucciones.
Las declaraciones de variables y definiciones de constantes deben
hacerse antes de ninguna instrucción.
Por tanto, estructura de programa:
program nombre_programa
declaración variable o definición constante 1
declaración variable o definición constante 2
...
sentencia 1
sentencia 2
...
end
Se analiza el siguiente ejemplo:

program circulo
real r, area

c Este programa lee un número real r y muestra

c el área del círculo con radio r.

write(*,*) 'Escribe el radio r:'

read (*,*) r
area = 3.14159*r*r
write(*,*) 'Area = ', area

end
•
SENTENCIAS
Las sentencias de un programa determinan las
acciones que el ordenador debe realizar para
resolver un problema. Son un conjunto de
palabras clave del lenguaje.
Estas sentencias, determinarán cómo se
deben tratar los datos y cómo se obtendrán
los resultados.
Podemos clasificarlas en distintos grupos
según su función. Así tenemos:
 SENTENCIAS DE ASIGNACIÓN
La forma general de las sentencias de
asignación hace uso del operador (=) en la
forma:
Variable = expresión
También se puede utilizar sentencias de
asignación con variables o constantes que
representan cadenas de caracteres, por
ejemplo en la forma:
Nombre = "Rigoberto"
 SENTENCIAS DE ENTRADA/SALIDA
SENCILLAS
Fortran permite utilizar sentencias de
entrada/salida muy sencillas, en las que casi
todas las opciones son las de defecto.

Existen otras sentencias de entrada/salida más

complejas. Las primeras están controladas por la
lista de variables a leer o escribir. Las segundas
tienen formatos específicos que controlan todos
los detalles.
 Sentencias PRINT y WRITE
La sentencia PRINT permite imprimir variables y
constantes en la salida estándar, que de ordinario es
la consola desde la que se está ejecutando el
programa.
A continuación se muestra la forma general y algunos
ejemplos de sentencia PRINT sin formatos:
PRINT *, lista_de_variables_y_constantes_separadas_por_comas
PRINT *, "Mi nombre es ", nombre, ".“
PRINT *, "Velocidad = ", velocidad, "m/s."
PRINT *
Cada sentencia PRINT empieza en una nueva
línea. Si se utiliza sin ninguna variable o
constante a imprimir, simplemente produce
una línea en blanco.
La sentencia WRITE es similar a PRINT, con la
posibilidad adicional de elegir otras unidades
de salida tales como impresoras y ficheros.
También se puede utilizar WRITE sin variables,
en cuyo caso imprime una línea en blanco.
WRITE (*, *) lista_de_variables_y_constantes_a_imprimir
WRITE (*, *)
 Sentencia READ
La sentencia READ hace que se adquieran ciertos
valores (normalmente desde teclado) desde una o
más líneas de entrada y que se asignen a la lista de
variables de la sentencia.
Cuando el programa llega a una sentencia READ
espera a que el usuario introduzca los valores de las
variables que deben ser leídas. Por este motivo
siempre es conveniente, antes de llamar a la
sentencia READ, imprimir un mensaje por la consola
solicitando los datos.
A continuación se muestra una forma general y un
ejemplo de sentencia READ:
READ (*,*) lista_de_variables_separadas_por_comas
READ (*,*) velocidad, tiempo
Cada vez que se ejecuta la sentencia READ se procesa
una nueva línea de datos de entrada.
Los distintos datos se separan mediante comas, o
mediante uno o más espacios en blanco.
 PALABRAS
RESERVADAS
DE FORTRAN
Como todos los lenguajes de programación,
Fortran tiene algunas palabras reservadas, que
los programadores deben abstenerse de
utilizar.

Algunas palabras reservadas de Fortran son las

siguientes:
• ALLOCATE
• ONLY
• ALLOCATABLE
• OPEN
• CALL
• OUT
• CASE
• PARAMETER
• CHARACTER
• POINTER
• COMPLEX
• PRINT
• CONTAINS
• TARGET
• CYCLE
• THEN
• DEALLOCATE
• TYPE
• DEFAULT
• UNIT
• DIMENSION
• USE
• DO
• WHERE
• END
• WRITE
• EXTERNAL • PROGRAM
• FUNCTION • READ
• IF • REAL
• IMPLICIT
• IN • RECURSIVE
• INOUT • RESULT
• INTEGER • RETURN
• INTENT • SAVE
• INTERFACE • SELECT
• INTRINSIC
• KIND • LOGICAL
• STOP • MODULE
• SUBROUTINE • NONE
• WHERE • STAT
• EXIT
Uso del comando FORMAT
y los descriptores del
formato
 Sentencia Format
Hasta ahora hemos analizado las sentencias de
entrada/salida que están controladas por una lista de
variables a leer o escribir; denominada de formato
libre.

write(*,*) lista_de_variables

Sin embargo, todo programador desea indicar algún

formato de entrada o salida, por ejemplo, el número
de decimales que tendrá un número real. Para este
propósito Fortran tiene la sentencia format.
 Sintaxis
write(*, etiqueta) lista_de_variables
etiq format (códigos_de_formato)

A continuación se muestra un ejemplo para demostrar como

funciona el comando.
Supongamos que se tiene una variable entera que se quiere mostrar
con un ancho de 4 caracteres y un número real que se quiere mostrar
en notación de punto fijo con 3 decimales.
write(*, 900) i, x
900 format (I4,F8.3)

La etiqueta 900 de la sentencia format es escogida en forma

arbitraria. Después de la palabra format se ponen los códigos de
formato encerrados entre paréntesis. El código I4 indica que un
entero tendrá un ancho de 4 y F8.3 significa que el número deberá
mostrarse en notación de punto fijo con un ancho de 8 y 3
decimales.
 Códigos comunes de formato
Las letras para códigos de formato más comunes son:
A - cadena de texto
D - números de doble precisión, notación
científica
E - números reales, notación científica
F - números reales, formato de punto fijo
I - entero
X - salto horizontal (espacio)
/ - salto vertical (nueva línea)

El código de formato F (y similarmente D y E) tiene la forma general

Fa.d donde a es una constante entera indicando el ancho del
campo y d es un entero constante que indica el número de dígitos
significativos.
Para los enteros solamente es indicado el ancho de
campo, por lo que la sintaxis es Ia.

Si un número o cadena no llena todo el ancho del

campo, se agregan espacios.

Para un espaciado horizontal (espacios), es usado el

código nX. Donde n indica el número de espacios
horizontales. Si n es omitido se asume n=1.
Para un espaciado vertical (nuevas líneas) se usa el
código /. Donde cada diagonal corresponde a una
nueva línea.
 Algunos Ejemplos
El siguiente código de Fortran
x = 0.025
write(*,100) 'x=', x
100 format (A,F)
write(*,110) 'x=', x
110 format (A,F5.3)
write(*,120) 'x=', x
120 format (A,E)
write(*,130) 'x=', x
130 format (A,E8.1)

Una vez que es ejecutado, genera la siguiente salida :

x= 0.0250000
x=0.025
x= 0.2500000E-01
x= 0.3E-01
Nótese que los espacios en blanco son automáticamente
puestos del lado izquierdo y que el ancho del campo por
default para números tipo real es usualmente de 14. Se
puede ver también que Fortran sigue la regla de redondeo
donde los dígitos del 0-4 son redondeados hacia abajo y
los dígitos del 5-9 son redondeados hacia arriba.

En este ejemplo cada sentencia write usa una sentencia

format diferente. Pero es correcto usar la misma
sentencia format varias veces con distintas sentencias
write. De hecho, esta es una de las principales ventajas
de usar sentencias format. Esta característica es buena
cuando se muestra el contenido de una tabla por ejemplo,
y se desea que cada renglón tenga el mismo formato
format.
 ¿Qué es un fichero?

• Podemos definir un fichero o archivo como

una unidad de información almacenada en
memoria secundaria, un disco, a la que se
asigna un identificador único; los ficheros nos
ofrecen la posibilidad de almacenar datos de
una manera permanente.
• Los ficheros pueden considerarse como
estructuras secuenciales en las que se
almacenan datos pertenecientes a un mismo
tipo; así podemos tener ficheros de texto
(caracteres), ficheros de tipo entero o, más
habitualmente, ficheros de registros (por
ejemplo, un fichero que almacene los datos de
los alumnos de una asignatura).
 Uso de ficheros en FORTRAN
• FORTRAN como todos los lenguajes de programación
modernos permite el manejo de ficheros.
• Para acceder a los ficheros el lenguaje FORTRAN utiliza lo que
se denominan números de unidad; a cada fichero abierto en
un programa se le debe asignar un número de unidad,
variando dichos números en el rango [1, 99] y existiendo dos
números de unidad reservados: el 5 y el 6,
correspondiéndose al teclado y a la pantalla,
respectivamente.
 Apertura y cierre de ficheros

• Las operaciones de apertura y cierre de

ficheros en FORTRAN son:

• open (unit=unidad, file=ruta del fichero)

• close (unidad)
• Como se puede ver, la acción open recibe tres
argumentos:

• 1. Unidad: Un número entero entre 1 y 99,

ficheros distintos deben tener asignados
números de unidad diferentes y no se debe
abrir un fichero sobre una unidad ya asignada
sin cerrar previamente el fichero antiguo.
• Si se abre de esta forma la unidad 5
podríamos leer del teclado (aunque nunca
escribir) y si es la unidad 6 la abierta
podríamos escribir en pantalla (aunque nunca
leer).

• El número de unidad asignado a un fichero en

el momento de la apertura es fundamental
puesto que será utilizado a partir de ese
momento en todas las operaciones que deban
acceder al fichero.
• 2. Ruta del fichero: Un fichero siempre se almacena en
memoria secundaria, esto es, en disco; mientras que en la
notación algorítmica la ruta del fichero nos era indiferente
resulta muy importante a la hora de implementar un
programa en un lenguaje. La ruta es una cadena de caracteres
(un literal o una variable) que indica la “localización” del
fichero, por ejemplo:

‘[Link]’ ó ‘c:\dir\subdir\[Link]’.
 Escribir en un fichero

• La sentencia PRINT empleada para presentar

datos por pantalla es una simplificación de la
sentencia WRITE.

• Esta presenta todas las capacidades que nos

ofrece PRINT pero además permite la
escritura de datos en fichero. Su construcción
y descripción se muestran a continuación:
• La sentencia general es:

WRITE (unit = Unidad, FMT = Formato) Lista

• En donde Unidad es una expresión entera que indica la

unidad de entrada y salida del fichero en el que se escribirán
los datos. Este parámetro es obligatorio y siempre debe
aparecer a continuación del paréntesis, es decir el primero.
Con este parámetro relacionaremos la sentencia OPEN y
WRITE para que la escritura se produzca en el fichero
deseado.
• Si este parámetro es sustituido por un *,
significara que la escritura será por pantalla y
por lo tanto equivaldrá a PRINT*, la cual ya la
conocemos.

• Formato puede ser un entero que indica el

numero de etiqueta en el que se encuentra
especificado el formato de escritura
establecido.
• Si este parámetro es sustituido por un *,
indicara que la escritura se va hacer con
formato libre, es decir igual que como hace
con la sentencia PRINT*.

• Lista, aquí deberán aparecer los nombres del

conjunto de variables que se van a escribir que
como ya es sabido deberán estar separadas
por comas.
 Ejemplos

• Sentencia:

WRITE( 10, * )A,B

• Acción:
• Se sitúa en el fichero con dirección de unidad 10 y escribe A y
B con formato libre.
• Para conocer el nombre del fichero habrá que buscar la
sentencia OPEN con UNIT=10
• Sentencia:

WRITE(20,200) (A(I), I=1,5)

• Acción:
• Se sitúa en el fichero con dirección de unidad 20
y escribirá los datos almacenados en la variable
A(I) del 1 al 5, con el formato especificado en la
sentencia de formato con etiqueta 200.
• Sentencia:

WRITE(*,*)AS

• Acción:
• Escribirá la variable AS por pantalla y con
formato libre. Esta sentencia equivale a:
PRINT*,AS
• Una expresión lógica únicamente puede tomar
dos valores que son:

• .true. O .false.

• Este tipo de expresiones permite crear

estructuras de control dentro del programa
FORTRAN que dependiendo de los valores
obtenidos se bifurcan y recorren caminos
alternativos.
• A la hora de construir una expresión lógica
FORTAN cuenta con una serie de operadores
lógicos que se aplican siempre entre dos
elementos del mismo tipo, bien numéricos o
bien tipo carácter, una vez construida la
expresión ésta puede tomar únicamente dos
valores “cierto” o “falso”.
• Los operadores en FORTRAN son los siguientes:

SIMBOLO SIGNIFICADO
.EQ. Igual que (=)
.NE. No igual que (≠)
.LT. Menor que (<)
.LE. Menor o igual que (≤)
.GT. Mayor que (>)
.GE. Mayor o igual que (≥)
• Ejemplo:
Supongamos que una variable real A posee un valor
de 5.6 y otra variable real B posee un valor de 7.8, la
siguiente tabla muestra los valores lógicos para una
serie de expresiones lógicas:

EXPRESIÓN VALOR

(A .GT. 50.0) .FALSE.

(A .GE. B) .FALSE.

(A .NE. B) .TRUE.
• Por otro lado hay otro tipo de operadores lógicos que son
utilizados únicamente entre expresiones lógicas en
concreto .NOT. que opera sobre una sola expresión lógica y el
resto sobre dos. La siguiente tabla muestra este tipo de
operadores y su significado:

OPERADORES SIGNIFICADO
.NOT. Negación
.AND. Conjunción lógica
.OR. Disyunción lógica
.XOR. Cierto únicamente si una de las expresiones lógicas es
cierta
.EQV. Equivalencia
.NEQV. Negación de equivalencia
• Ejemplo:
• Supongamos dos variables con valores A=2.0 y
B=10.0, entonces:

• .NOT. (A .LT. B) .FALSE.

• (A .NE. B) .AND. (A .LT. B) .TRUE.
• (A .LT. B) .OR. (A .GT. B) .TRUE.
• (A .NE. B) .XOR. (A .LT. B) .TRUE.
• (A .LT. B) .EQV. (A .GT. B) .FALSE.
• (A .LT. B) .NEQV. (A .GT. B) .TRUE.
• Cuando en una misma expresión lógica compuesta existen
varios operadores la prioridad de mayor a menor es:

1. Paréntesis
2. Operadores aritméticos (**,*,/.+.-)
3. Operadores lógicos (.LT., .GT., .EQ., etc.)
4. .NOT.
5. .AND.
6. .OR.
7. .EQV. y .NEQV.

• Cuando en una misma expresión existen operadores de la

misma prioridad las operaciones se realizan recorriendo la
expresión de izquierda a derecha.
 El bloque IF…THEN…ELSE

• Conocida como estructura de selección.

• Esta examina una condición.
• Si es verdadera se ejecuta un bloque de
instrucciones (READs, WRITEs y/o GO TOs).
• Si la condición es falsa, el control va
directamente a otro bloque diferente de
preposiciones.
• Con la siguiente estructura:
• IF (condición o expresión lógica) THEN
• ELSE IF (condición)THEN
• ELSE
• END IF
• El IF se divide en IF lógico y en IF aritmético,
solamente en la actualidad se utiliza el IF
lógico por esta razón solo se hablara del IF
lógico:
• Forma general del IF lógico
• IF(expresió[Link]ón. expresión) condición
• Se comparan 2 condiciones. Sil la condición es
verdadera, se ejecuta la única preposición que
sigue a la condición; si la condición es falsa, no
se ejecuta la preposición.
• Por ejemplo:
• IF([Link].0)N=N+1
• Si el valor NUMERO es mayor o igual a cero, se
ejecutara la preposición N=N+1. Si el valor
NUMERO es negativo, no se ejecuta la
preposición.
 Bibliografía
• [Link]
tamarit/numerico/[Link]
• [Link]
so_de_fortran-estructuras_de_control_selecti
vas_y_repetitivas/6644-3
• [Link]
ma3_3.htm
 CICLOS SIMPLES
En FORTRAN es posible
definir un ciclo simple
“con contador”
codificando un ciclo DO
(haga). En la siguiente Ciclo Ciclo DO
tabla se muestra del codificado
lado izquierdo un ciclo K=1 DO K=1 ,N
codificado y del lado 10 ISUM=ISUM+K ISUM=ISUM+K
derecho un ciclo DO K=K+1 END DO
equivalente. IF (K .LE. N) GO

TO 10
 La forma general de un ciclo DO es:
DO variable = inicial, limite, incremento,

una variable entera simple que

se usará como variable de control

el valor inicial de la variable de control

el valor del limite superior de la variable de control

el incremento; esto es, la cantidad por la cual se incrementara

la variable de control en cada nuevo paso a través del ciclo
(Opcional)
c EJEMPLO: Programa de la suma de los enteros con un ciclo DO
c
c
c
c
c
READ (*,*) N
ISUM=0
DO K=1 ,N
ISUM=ISUM+K
END DO
WRITE (6,*) N, ISUM
END
 Estructuras lógicas básicas

Repetitiva o iterativa: permite repetir una

composición tantas veces como sea necesario
(el número de veces debe ser finito)
 Iteración de pasos variables
(DO WHILE)

Este tipo de ciclo ejecuta un bloque de sentencias

repetidamente, mientras una condición lógica sea
verdadera. La sintaxis de un ciclo DO WHILE es la
siguiente:

DO WHILE (expresión lógica)

END DO

Las diferencias entre DO y DO WHILE son mínimas, de

hecho tanto las características como las restricciones
son muy similares.
 Los siguientes pasos ocurren cuando una sentencia
DO WHILE es ejecutada:

1.- Se evalúa la expresión lógica

2.- Si la expresión es falsa, no se ejecuta ninguna

sentencia dentro del rango del DO WHILE. La
ejecución salta a la sentencia que sigue de la
sentencia de término del ciclo.
3.- Si la expresión es verdadera, son ejecutadas las
sentencias dentro del ciclo, comenzando en la
primera sentencia que sigue de la sentencia DO
WHILE.

4.- Cuando se ha ejecutado todas las sentencias del

bloque, la ejecución retorna a la sentencia DO
WHILE. La expresión lógica se evalúa y este ciclo
se repite.
 Ciclo Do- while (mientras)

El do while se encuentra dando ciclos mientras

no llegue a satisfacer la expresión lógica, y su
formato es:
[etiqueta:] DO While (expresión lógica)
--------- rango de el ciclo
End do while
Ejemplo: Se desea imprimir los números enteros del
1 al 10

real A

INTEGER i, imax
imax=10
a=0
i=1
do while([Link])
a=a+i
write(*,*)a
end do
end
 ANIDACION DEL DO
• Una aplicación común del DO consiste en
anidar unos dentro de otros para obtener así
una estructura de programa compacta.
• La anidación consiste en comenzar un bucle
DO dentro de otro. De esta forma se consigue
tener dos o más contadores variando
simultáneamente.
• Existen unas reglas que hay que tener en
cuenta al anidar bucles DO:

– Debe haber una sentencia END DO por cada

DO.
– El primer END DO se corresponde con el
último DO definido.
– Cada bucle tendrá su propio contador.
– Se pueden mezclar distintas sintaxis del DO en
anidación
Unidad V
 Concepto de subprograma
Un subprograma es un conjunto de
instrucciones en secuencia que aparecen
una sola vez fuera del programa principal
y se utiliza para evitar una repetición de
ese mismo conjunto de instrucciones en
diferentes lugares de dicho programa
principal.
En FORTRAN se emplean funciones y subrutinas,
el subprograma para definir una función se
conoce como subprograma FUNCTION, el
subprograma para definir una subrutina es el
subprograma SUBROUTINE.
 Subprograma FUNCTION

La utilidad del FUNCTION es evidente; nos

permite construir funciones especiales, según
nuestras propias necesidades de programación.
La llamada de un FUNCTION es igual a la llamada
de funciones de biblioteca como es el caso de
SIN(X), ABS(X), esto es, dado un valor al
argumento, el subprograma FUNCTION nos
calcula un valor que corresponde a la función
en sí, asignando dicho valor al nombre propio
de la función.
Función que evalúa un polinomio de segundo orden:

CPROGRAMA PRINCIPAL
X=3.0
Y=F(X,A,B,C)
C LA FUNCION ESTA DEFINIDA EN EL
C SUBPROGRAMA. SU NOMBRE ES F
C SUS ARGUMENTOS SON X,A,B,C
...
END
El subprograma FUNCTION:
C FUNCTION F(X,A,B,C)
F=A*X**2+B*X+C
RETURN
END
Un subprograma FUNCTION puede manejar
varios argumentos que deben corresponder
en número y modo con los definidos en el
programa que lo va a usar, (en este caso 4
argumentos reales); la característica distintiva
es que el FUNCTION regresa sólo un valor
como resultado y dicho valor se asocia con el
nombre del FUNCTION mismo (en este caso F
con lo que se sabe que es una función real).
El subprograma FUNCTION recibe los valores de
los argumentos al mencionarse la función en
el programa principal, inmediatamente evalúa
el proceso indicado en el FUNCTION y regresa
por efecto del RETURN a la instrucción misma
que lo llamó para de ahí continuar con el
programa
 FUNCIONES

• En Fortran se consideran tres tipos de

funciones:
– Intrínsecas o predefinidas
– Fórmulas
– Externas.
 Funciones intrínsecas o predefinidas

• Como Fortran es un lenguaje orientado al desarrollo

de aplicaciones matemáticas considera un
importante núcleo de funciones matemáticas, de
manera que ellas pueden ser utilizadas sin necesidad
de codificarlas ni de declararlas.
• Estas funciones, que pertenecen a la librería interna
de Fortran, se les llaman funciones intrínsecas o
predefinidas.
• Las funciones intrínsecas pueden aparecer
dentro de cualquier expresión y tienen la
prioridad máxima.
• La forma general de invocar una de función
de este tipo es la siguiente:

NOMBRE_FUNCION( X1, X2,... ,Xn )

• La siguiente es una lista de algunas
de las funciones intrínsecas estándar
del ForTran:
Funciones aritméticas
 Funciones matemáticas o
trigonométricas (sobre radianes)

Funciones sobre
complejos
 Funciones de Sentencia

• Las Funciones de Sentencia es una manera

más ágil para declarar funciones sencillas,
siguiendo las formas de las funciones
matemáticas.
• En efecto, es posible decir que f (x, y) = 3x +
y2 + pi; puede ser declarada simplemente
como:
F(X,Y)=3.0*X+Y**2+PI
• Una función de Sentencia permite hacer lo
anterior utilizando, como dijimos, el formato
usual de las funciones matemáticas a = b, donde a
es el nombre de la función y b representa una
expresión.
• El nombre de la función va seguido de un
paréntesis que encierra el o los argumentos,
separados por comas, si es que hay más de uno.
• El segundo miembro de la proposición de
definición puede ser cualquier expresión que no
contenga variables con subíndices.
• Esto es tan sólo la definición de la función; no origina
ningún cálculo.
• Los nombres de las variables usadas como
argumentos son mudos; pueden ser iguales que los
nombres de las variables que aparecen en cualquier
otra parte del programa.
• Una proposición de función aritmética se usa
escribiendo su nombre dondequiera que se desee el
valor de la función añadiéndole cualquier expresión
apropiada para sus argumentos. El valor de estas
expresiones era sustituido en la parte del programa,
establecida por la definición y entonces el valor de la
función será calculado.
 Funciones Externas

• Pese a lo útil que suelen ser las Funciones

de Sentencia, éstas tienen, sin embargo,
dos restricciones importantes: la definición
está limitada a una sola proposición y
pueden calcular solamente un valor. Las
funciones externas (FUNCTION) superan la
primera limitante, mientras que las
subrutinas (SUBROUTINE) superan ambos.
• Las funciones externas, tal como su nombre lo
indica, son externas al programa. Por lo tanto
pueden ser compiladas separada e
independientemente de él. Cada una de ellas
generará un código objeto diferente y al
momento de enlazarlas se adjuntan el
programa principal para dar origen a un único
programa ejecutable.
• Los nombres de las variables, tanto para funciones
como para subrutinas, son completamente
independientes de los nombres de las variables del
programa principal y de otros subprogramas.
• Una función externa se define escribiendo las
sentencias necesarias para su funcionamiento entre
las sentencias FUNCTION y END.
• El nombre de la función, así como la lista de
parámetros (separados por coma y entre paréntesis)
y el tipo al que corresponde el resultado, este último
puede estar definido de manera implícita en el
nombre de la función.
• Los argumentos en el nombre de la función deberán
ser diferentes variables sin subíndices. Sin embargo,
dentro del subprograma en sí, pueden usarse
libremente las variables con subíndices. El
subprograma debe contener, por lo menos, una
proposición de regreso (sentencia RETURN).
• La función es llamada simplemente usando el
nombre de la función y haciendo una lista de
argumentos entre paréntesis.
• Se puede observar que la estructura de una
función es parecida a la del programa principal.
Las diferencias son:
– Las funciones tienen un tipo. El tipo debe coincidir con
el tipo de la variable que recibirá el valor.
– El valor que devolverá la función, deberá ser asignado
en una variable que tenga el mismo nombre que la
función.
– Las funciones son terminadas con la sentencia return
en vez de la sentencia stop.
• Para resumir, la sintaxis general de una
función externa en Fortran es:
tipo function nombre (lista_de parámetros)
declaraciones
sentencias
return
end
 EJEMPLO

• Supongamos el siguiente problema:

Un meteorólogo ha estudiado los niveles
de precipitación en el área de una bahía y ha
obtenido un modelo (función) ll(m,t) donde ll
es la cantidad de lluvia, m es el mes, y t es un
parámetro escalar que depende de la
localidad. Dada la fórmula para ll y el valor de
t, calcular la precipitación anual
• La forma obvia de resolver el problema es
escribir un ciclo que corra sobre todos los
meses y sume los valores de ll. Como el
cálculo del valor de ll es un subproblema
independiente, es conveniente implementarlo
como una función. El siguiente programa
principal puede ser usado:
program lluvia
real r, t, suma
integer m
write(*,*) 'Ingrese el parámetro escalar t '
read (*,*) t
suma = 0.0
do m = 1, 12
suma = suma + ll(m, t)
end do
write (*,*) 'La precipitación Anual es ', suma,
'pulgadas'
stop
end
• Además, la función ll tiene que ser definida como
una función de Fortran. La fórmula del
meteorólogo es:
ll(m,t) = t/10 * (m**2 + 14*m + 46) si la expresión es positiva
ll(m,t) = 0 otro caso

• La correspondiente función en Fortran es

real function ll(m,t)
integer m
real t
ll = 0.1*t * (m**2 + 14*m + 46)
if (ll .LT. 0) ll = 0.0
return
end Ejecución en Fortran
Diferencia entre módulos
y subprogramas externos
de función
La resolución de un determinado problema se
puede llevar a cabo mediante subprogramas o
procedimientos que realizan por separado una
tarea determinada. Tales subprogramas, son
“invocados” desde el programa principal.

Los subprogramas pueden ser internos o externos.

Los subprogramas internos están contenidos dentro
del programa principal y son compilados a la vez,
mientras los subprogramas externos son
compilados separadamente.
 SUBPROGRAMA EXTERNO
• Función o subrutina no contenida en el
programa principal, en un módulo o cualquier
otro subprograma.

• Define un procedimiento a realizar y puede

ser llamada por cualquier unidad del
programa.
Los subprogramas externos residen en ficheros
separados del programa principal, y se consideran
externos en el sentido de que pueden ser invocados
por diferentes programas para realizar una tarea
determinada. Su estructura es la siguiente:
SUBROUTINE nombre [(argumentos)]
o FUNCTION nombre [(argumentos)]
sentencias de declaración
sentencias de declaración
sentencias ejecutables
sentencias ejecutables
END SUBROUTINE nombre
END FUNCTION nombre
Los subprogramas externos, pueden ser utilizados
por cualquier otro programa o subprograma. El
código de un subprograma externo se puede ubicar:
• En un fichero, aparte de cualquier otro programa o
subprograma.

• En el mismo fichero que otro programa o

subprograma, pero “fuera" de él, es decir, después
de la instrucción END PROGRAM, END FUNCTION o
END SUBROUTINE.

• En un módulo de subprogramas.
Las funciones externas o en general, los
subprogramas externos son accesibles desde un
programa principal porque se incluyen en el
mismo fichero, después de la sentencia END
PROGRAM.

En este caso ni el programa principal accede a

variables de la función externa, ni ésta a las
variables o funciones declaradas en el programa
principal. El único “canal” de comunicación abierto
entre ambos son los argumentos con los que el
programa principal llama a la función externa.
 MÓDULOS
• Contienen definiciones que pueden ser
accesibles para otras unidades programáticas,
como:
definiciones de datos y sus tipos, definiciones
de procedimientos (módulo de subprograma)
y procedimientos de interfaces
• Pueden ser funciones o subrutinas.
• Pueden ser llamados por otros módulos o
por otro programa que tenga acceso al
módulo.
Los módulos sirven para declarar variables que
se usan en muchos subprogramas, o para
agrupar muchos subprogramas en una sola
unidad. Los módulos comienzan por module
nombre y terminan con end module nombre. A
diferencia de las funciones y subrutinas, si el
módulo está en el mismo archivo que el
programa principal, debe estar antes que éste.
Cualquier subprograma que haga uso del
módulo debe hacerlo mediante el comando use
nombre.
Los módulos son ficheros que contienen declaraciones de
variables con sus tipos, subprogramas y definiciones de
nuevos tipos de variables. Los módulos definen librerías de
utilidad, que pueden ser incorporadas a muchos programas
diferentes.
Los módulos se definen en la forma siguiente:
MODULE nombre_modulo
CONTAINS
Subprograma_1
Subprograma_2
END MODULE nombre_modulo
Los módulos se almacenan en ficheros fuente especiales, que deben
ser compilados de forma independiente que el programa principal.
En el momento de crear el ejecutable hay que proporcionar también
los ficheros objeto resultantes de la compilación de los módulos.
Para que un programa principal pueda hacer uso de las funciones de
un módulo hay que incluir en él (al comienzo de la parte de
especificación) la sentencia USE, en una de las formas siguientes:
USE nombre_modulo
o bien:
USE nombre_modulo ONLY: lista_de_identificadores
En este segundo caso sólo se podrán utilizar las variables y
subprogramas que hayan sido especificados.
Existe la posibilidad de cambiar el nombre (para usar un nombre
distinto en el programa principal) de algunos identificadores. Esto se
hace construyendo la lista en la forma:
USE nombre_modulo ONLY: nuevoNombre1 => nombre1,
nuevoNombre2 => nombre2, nombre3
Un módulo es una unidad no ejecutable que será utilizada por el programa
principal mediante la sentencia USE y que puede incluir subrutinas,
funciones, etc. Los módulos se compilan separadamente.
Ejemplo:
MODULE____________________________PROGRAM

MODULE FUNC_CUAD
PROGRAM CUADRADO
CONTAINS
USE FUNC_CUAD
FUNCTION F(x), RESULT (f_result)
IMPLICIT NONE
REAL, INTENT (IN) :: x
REAL y
REAL :: f_result READ*, y
f_result = x ** 2 PRINT*, F(y)
END FUNCTION F
END PROGRAM CUADRADO
END MODULE FUNC_CUAD
 Ejemplo
C Programa “usamodulos”
C Modulo "constantes".
module constantes
C Declarar parametros.
implicit none
real, parameter :: pi=3.141592, ee=2.71828
C Termina modulo.
end module constantes
C Programa principal
program usamodulos
C Usar modulo "constantes".
use constantes
C Declarar variables.
implicit none
 real radio,area
real ee2
C Definir radio y calcular area y ee2.
radio = 10.0
area = pi*radio**2
ee2 = ee**2
C Escribir resultados a pantalla.
print *
print *, ’El area de un circulo de radio
’,radio,’ es ’,area
print *
print *, ’El cuadrado el numero de Euler es
’,ee2
print *
C Termina programa.
end program usamodulos
 BIBLIOGRAFÍA
• [Link]
[Link]
 BIBLIOGRAFÍA
• [Link]
curso_de_fortransubprogramas_y_funciones_
en_fortran/6644-5
• [Link]
tutor_fort/[Link]
• [Link]
general/lenguajefortran/
[Link]#p2
 Bibliografía
[Link]
semic2/cmorant_archivos/right_archivos/ICC/
Introduccion%20al%[Link]
[Link]
programacion/fortran/[Link]
[Link]
aprendainf/Fortran90/[Link]
• Cuando un programa tiene más de cien líneas,
es difícil de seguir. Los códigos de Fortran que
resuelven problemas reales de ingeniería por
lo general tienen decenas de miles de líneas.
• La única forma para manejar códigos tan
grandes, es usar una aproximación modular y
dividir el programa en muchas unidades
independientes pequeñas llamadas
subprogramas.
• Un subprograma es una pequeña pieza de
código que resuelve un subproblema bien
definido.

• En un programa grande, se tiene con

frecuencia que resolver el mismo
subproblema con diferentes tipos de datos.

• En vez de replicar el código, estas tareas

pueden resolverse con subprogramas.
• El mismo subprograma puede ser llamado
varias veces con distintas entradas de datos.
• En Fortran se tienen dos tipos diferentes de
subprogramas, conocidas como funciones y
subrutinas.
• Una función de Fortran puede devolver únicamente
un valor. En ocasiones se desean regresar dos o más
valores y en ocasiones ninguno. Para este propósito
se usa la construcción subrutina. La sintaxis es la
siguiente:

subroutine nombre (lista_de_parámetros)

declaraciones
:
sentencias
:
return
end
• Obsérvese que las subrutinas no tienen tipo y
por consecuencia no pueden hacerse
asignación al momento de llamar al
procedimiento. Se da un ejemplo de una
subrutina muy sencilla. El propósito de la
subrutina es intercambiar dos valores enteros.
subroutine iswap (a, b)
integer a, b
! Variables locales
integer tmp
! Sentencias
tmp = a
a=b
b = tmp
return
end
• Se debe observar que hay dos bloques de
declaración de variables en el código. Primero,
se declaran los parámetros de entrada/salida,
es decir, las variables que son comunes al que
llama y al que recibe la llamada.
• Después, se declaran las variables locales, esto
es, las variables que serán sólo conocidas
dentro del subprograma. Se pueden usar los
mismos nombres de variables en diferentes
subprogramas.
las subrutinas son subprogramas que no devuelven ningún
resultado, por tanto no tienen tipo.

Se envían y reciben mediante los parámetros formales y

los bloques comunes (common). Es por tanto, un programa
independiente del principal, ligado a este únicamente por
los datos que se envían y reciben

Las subrutinas se diferencian de las funciones

fundamentalmente en la sintaxis de la definición y en la
forma de invocarlos; dado que no tienen tipo alguno

Las subrutinas no pueden formar parte de expresiones ni

aparecer en la parte derecha de una sentencia de asignación,
deben aparecer única y exclusivamente en una sentencia de
llamada a procedimiento.
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).
Los argumentos y variables declaradas dentro del cuerpo de
una función (o subrutina) se denominan variables locales, las
variables declaradas dentro del programa principal son
variables globales.

Los subprogramas tienen acceso a las variables globales

aunque en el caso de que una variable local se denomine igual
que una variable global tiene preferencia la primera.
Las subrutinas son subprogramas que no devuelven ningún
resultado; sin embargo, gracias a la utilización de los efectos
laterales es posible su utilización para permitir el “retorno” de
varios resultados.
Las subrutinas y funciones extrínsecas son trozos de
programa que se definen separadamente del programa
principal, y sus variables necesitan ser definidas en la
subrutina ya que son variables locales, no compartidas con el
programa principal o con las de otras subrutinas.

Se definen mediante la instrucción SUBROUTINE. La

subrutina ha de acabar con un END. La sintaxis completa es

SUBROUTINE nombre (lista de argumentos)

...
END
La subrutina se invoca con la instrucción CALL
Un ejemplo de utilización de subrutinas es la transformación
entre coordenadas polares y cartesianas:
PROGRAM POLAR_CARTES
REAL X, Y, RHO, THETA
READ (*,*) RHO, THETA
CALL POLARES (X, Y, RHO, THETA)
PRINT *, X, Y
END
SUBROUTINE POLARES (X, Y, RHO,
THETA)
REAL X, Y, RHO, THETA
X = RHO * COS (THETA)
Y = RHO * SIN (THETA)
END