Parafraseo

Renzo Javier Capcha De la Cruz - 18130059

Subrutinas son procedimientos más generales que las funciones Aunque comparten casi todas
sus características pueden retornar más de un valor o no retornar nada en absoluto recibe los
valores de entrada y devuelven los valores de salida a través de su lista de argumentos.

La estructura general de una subrutina es idéntica a la de una función:

 Cabecera de subrutina
 Sección de especificaciones
 Sección ejecutable
 terminación de subrutina

Donde la sintaxis general de la cabecera de su rutina es:

SUBROUTINE NOMBRE_SUBRUTINA ([lista de argumentos formales])

Y la sintaxis general de la terminación de subrutina es:

END SUBROUTINE [NOMBRE_SUBRUTINA]

La sección de especificaciones incluye la declaración de los tipos de los argumentos formales

con su atributo intent correspondiente a su intención de uso y la de las variables locales a la
subrutina si las hay.

La sintaxis general de llamada a una subrutina desde cualquier unidad de programa es:

CALL nombre_subrutina ([lista de argumentos actuales])

La ejecución de la llamada ocurre de la siguiente manera:

Se evalúan los argumentos actuales que son expresiones.

 Se asocian los argumentos actuales con sus correspondientes argumentos formales. El

paso de los argumentos se realizan por dirección.
 Se ejecuta el cuerpo de la subrutina especificada
 Se devuelve el control a la unidad de programa que hizo la llamada en concreto a la
sentencia siguiente de la sentencia CALL.
 La subrutina no devuelve ningún valor a través de su nombre sino que son los
argumentos los encargados de realizar las transferencias de resultados.

Debe de haber concordancia en el número tipo y orden de los argumentos actuales y sus
correspondientes argumentos formales al igual que en las funciones.

Ejemplo: sea la subrutina para convertir grados minutos y segundos a grados decimales.

SUBROUTINE CONVIERTE(GRADOS,MINUTOS,SEGUNDOS,GRADOS)

INTEGER,INTENT(IN)::GRADOS,MINUTOS,SEGUNDOS

REAL,INTEGER::GRADS
GRADS=REAL(GRADOS)+REAL(MKINUTOS)/60.+REAL(SEGUNDOS)/3600

END SUNROUTINE CONVIERTE

Llamadas validas desde un programa principal son:

PROGRAM PRINCIPAL
INTEGER::G,M,S
REAL::N,GD
…
CALL CONVIERTE (30,40,2,N) !LLAMADA 1
WRITE (*.*) ‘30 GRADOS, 45 MINUTOS, 2 SEGUNDOS EQUIVALEN A’
WRITE (*.*) N, ‘GRADOS DECIMALES’
CALL CONVIERTE (G,M,S,GD) !LLAMADO 2
WRITE (*.*) G, ‘GRADOS’, M, ‘MINUTOS’, S, ‘SEGUNDOS EQUIVALEN A’
WRITE (*.*) GD, ‘GRADOS DECIMALES’
…
END PROGRAM PRINCIPAL

Transferencia de array a procedimientos:

 Cuando la llamada a un procedimiento incluye el nombre de un array en un argumento

actual se transfiere la dirección de memoria del primer elemento del mismo de esta
manera el procedimiento es capaz de acceder al array Pues todos sus elementos
ocupan direcciones de memoria consecutivas.
 Además el procedimiento debe conocer el tamaño del array en concreto los límites de
los índices de cada dimensión para las operaciones efectuadas en el cuerpo del
procedimiento se realicen sobre elementos permitidos hay dos formas de hacerlo:

A)Array formal con perfil explícito consiste en pasar la extensión de cada dimensión del array
en la lista de argumentos y usarla en la declaración del array formal en el procedimiento. Esta
forma permite operaciones con arrays completos y subconjuntos de arrays dentro del
procedimiento

ejemplo:

CALL PROCED (MATRIZ, D1, D2, RESUL) !LLAMADA A SUBRUTINA

SUBROUTINE PROCED (MATRIZ, D1, D2, RESUL)

INTEGER, INTENT(IN):: D1,D2

INTEGER, INTENT(IN), DIMENSION(D1,D2)::MATRIZ !PERFIL EXPLICITO

INTEGER, INTENT(OUT)::RESULT

B) Array formal con perfil asumido la declaración de un array formal de este tipo usa dos
puntos para cada índice del mismo permite operaciones con arrays completos y subconjuntos
de arrays dentro del procedimiento el procedimiento debe tener interfaz explícita concepto
que se estudiará más adelante.

Compartir datos con módulos

Hasta ahora un programa fortran intercambia datos entre sus distintas unidades de programa
principal función subrutina a través de las listas de argumentos

Además de la lista de argumentos un programa fortran puede intercambiar datos a través de

módulos

Un módulo es una unidad de programa compilada por separado del resto que contiene al
menos las declaraciones inicializaciones necesarias de los datos que se quieren compartir entre
las unidades de programa

La sintaxis general de un módulo es:

 MODULE NOMBRE_MODULO
 [SAVE]
 DECLARACION E INICIALIZACION DATOS COMAPRTIDOS CUERPO DEL MODULO
 END MODULE NOMBRE_MODULO

La sentencia save es util para preservar los valores de los datos del módulo cuando éste se
comparte entre varias unidades de programa

Para poder usar los datos de módulo en una unidad de programa escribir la sentencia:

USE nombre_modulo1[,nombre_modulo2],...

Como primera Sentencia no comentada inmediatamente después del cabecero de la unidad

del programa que quieres usarlo.

Los módulos de datos son útiles cuando se necesita compartir grandes cantidades de datos
entre muchas unidades de programa pero manteniendo los invisibles para las demás

Ejemplo:

MODULE mod1
CONTAINS
SUBROUTINE sub1 (matriz)
INTEGER. INTENT(INUOT). DIMENSION(:.:)::matriz !perfil asumido
...
END SUBROUTINE sub1
END MODULE mod1

Ejemplo: escribir un módulo de datos que comparta dos vectores con valores iniciales V1 (1 1 1
1 1) Y V2(10 11 12 13 14) y una matriz m entre el programa principal y una subrutina sub. El
programa principal debe calcular el vector suma de v1 y v2 y la subrutina debe volcar el vector
suma en la primera columna de la matriz y el vector V2 en la segunda columna.
MÓDULO CONPARTE_DATOS
IMPLICITE NONE
SAVE
INTEGER,PARAMETER:: tm=5
INTEGER:: i
INTEGER,DIMENSIÓN(TM)::v1=1,v2=(/(i.i=10,14))
INTEGER,DIMENSIÓN(tm.2)::m
END MÓDULO COMPARTE_DATOS

PROGRAN PRINCIPAL
USE COMPARTE_DATOS
IMPLICIT NONE
INTEGER: WRITE(*.*) 'v1',V1
WRITE(*.*) 'V2’.V2
V1=V1+V2
WRITE(*.*) V1'.V1
CALL Sub
WRITE(*.*) ‘M’
DO i=1.TM
WRITE(*.*) (M(ij).j=1,2)
END DO END PROGRAM principal
SUBROUTINE sub
USE comparte_datos
IMPLICIT NONE
M(:,1)=V1
M(:,2)=V2
END SUBROUTINE sub

PROCEDIMIENTOS MODULO

Ademas de datos, un modulo puede contener procedimientos (Subrutinas y/o funciones)

procedimientos modulo.

La sintaxis general de un procedimento modulo es:

MODULE nombre_modulo

[SAVE]

Declaracion e inicializacion datos compartidos

CONTAINS

Estructura general procedimiento1

[Estructura general procedimiento2]

END MODULE nombre_modulo

Como ocurre con los modulos de datos, para hacer accesibles procedimientos modulos a una
unidad de programa, escribir:

USE nombre _modulo1[,nombre modulo2]…

Como la pimera sentencia no comentada, inmediatanente despues del cabecero de la unidad

de programa que quiere usarlo.

Un procedimiento contenido en un modulo se dice que tiene una interfaz explicita, pues el
compilador conoce todos los detalles de su lista de argumentos. Cono consecuencia, cuando se
usa el modulo en cualquier unidad de programa, el compilador chequea la concordancia de
numero, tipo y orden entre las listas de argumentos actuales y sus correspondientes formales,
asi como usos indebidos de los ultimos segun el valor del atributo INTENT.

por contraposición, un procedimiento externo fuera de un modulo se dice que tiene una
interfaz implicita. El compilador desconoce los detalles de las listas de argumentos y, por tanto,
no puede chequear errores de concordancia en las mismas. Es responsabilidad del
programador encargarse de chequearlo.

Ejemplo, Sumar dos numeros enteros usando un procedimento modulo

MODULO MOD1
CONTAINS
SUBROUTINE SUB1 (A,B,SUMAR)
IMPLICIT NONE
INTEGER,INTENT(IN)::A,B
INTEGER,INTENT(OUT)::SUMAR
SUMA=A+B
END SUBROUTINE SUB1
END MODULE MOD1
PROGRAM PRINCIPAL
USE ,MOD1
IMPLICIT NONE
INTEGER::X,Y,RESUL
WRITE(*.*) ‘DAME DOS MNUMEROS’
READ(*.*)X,Y
CALL SUB1(X,Y,RESUL)
WRITE(*.*) ‘LA SUMA ES’,RESUL
END PROGRAM PRINCIPAL

Comprobar que si se declaran los argumentos actuales del tipo real, el compilador encuentra el
error de concordancia de tipos. Sin embargo, si se repite el ejercicio con la subrutina sub1
como procedimiento externo, el compilador no encuentra errores.

Procedimientos como argumentos:

Los argumentos actuales de un procedimiento puede ser nombres de subrutinas o funciones
definidas por el programador. Como el paso de argumentos se realizan por dirección, en este
caso, se pasa la dirección de memoria de comienzo del procedimiento.

Si el argumento actual es una función, necesita el atributo external en su sentencia de

declaración de tipo, tanto en el procedimiento de llamada como en el procedimiento llamado.
La sintaxis general es:

TIPO,EXTERNAL:: nombre_función

Ejemplo:

PROGRAMA PRINCIPAL
IMPLICIT NONE
INTEGER::A=5, B=7
CALL SUB (FUN,A,B,X)
WRITE(*.*) ‘RESULTADO’,X
END PROGRAM PRINCIPAL

SUBROUTINE SUB (F,A,B,RES)

IMPLICIT NONE
REAL,EXTERNAL::F
INTEGER,INTENT(IN)::A,B
REAL,INTENT(OUT)::RES
RES=F(A)+B**2
END SUBROUTINE SUB
REAL FUNCTION FUN(A)
INTEGER,INTENT(IN)::A
FUN=(2.*A-5.)/7
END FUNCTION FUN

Si el argumento actual es una subrutina, es necesario escribir una sentencia external, tanto en
el procedimiento de llamada como en el procedimiento llamado. La sintaxis general es:

EXTERNAL:: nombre_subrutina

Procedimientos internos

Hasta ahora, se han estudiado dos tipos de procedimientos: los procedimientos externos y los
procedimientos módulo. Además, existe un tercer tipo de procedimiento, los llamados
procedimientos internos.

Un procedimiento interno es un procedimiento completamente contenido dentro de otra

unidad de programa. Llamada anfitrión o host. El procedimiento interno se compila junto con
su anfitrión y sólo es accesible desde el. Debe escribirse a continuación de la última sentencia
ejecutable del anfitrión, procedido por una sentencia contáins.

La estructura general de una unidad de programa que contiene un procedimiento interno es:

 Cabecero de unidad de programa

 Sección de especificaciones
  Sección ejecutable
 Procedimiento interno
 Fin de unidad de programa

Un procedimiento interno tiene acceso a todos los datos definidos por su anfitrión, salvo
aquellos datos que tengan el mismo nombre en ambos. Los procedimientos internos se usan
para realizar manipulaciones de bajo nivel repetidamente como parte de una solución.