Hasta el momento, hemos aprendido a trabajar con las distintas variables, y a usar estructuras para modificar el curso que toman nuestros programas, pero cuando nos enfrentamos a programas más extensos, que algunas veces necesitan ejecutar un mismo bucle para procesar ciertos datos, pero las variables no son las mismas, no es lo más cómodo copiar y pegar las mismas instrucciones varias veces, más todavía si tenemos que estar cambiando las variables cada vez que usemos el mismo algoritmo, para esto existen los subprogramas.

Un subprograma es una estructura que se agrega al final del programa y se puede invocar en cualquier parte del programa principal (perdonen que sea reiterativo con la palabra programa) indicando que variables participan dentro del subprograma, que cambios se les hacen, etc. Tenemos de dos tipos: functions y subroutines, sus diferencias son sutiles.

Una function (o función en castellano), son subprogramas que tienen 0 o más argumentos (variables) y que retornan un valor en el nombre, esto significa, por lo pronto, que su invocación debe estar al lado derecho de una asignación de valor a una variable y no puede formar una sentencia aislada dentro del programa. Ejemplificando:

variable=funcion(argumentos)

siempre va a la derecha la invocación de la función. La sintaxis para crear nuestras propias funciones en Fortran es la siguiente:

program programa_muestra
... sentencias e invocaciones de la función
end program

function nombre_funcion(argumentos)
declaración del tipo de argumentos
sentencias de la función
end function

¿Por qué meto una declaración del tipo de argumento en subprograma?, como una simple precaución, es importante que los tipos coincidan, por lo que si nos equivocamos al declarar una variable en el programa y compilamos, puede generar un error de ejecución desastroso que arruine todos nuestros datos, entonces si incluimos la declaración en el subprograma y nos equivocamos, lo más probable es que el compilador se queje y nos advierta de ello. Vamos a dar un ejemplo de una función de dos variables:

function mayor(aL,bL)
integer::aL,bL
if (aL .ge. bL) then
mayor=aL
else
mayor=bL
end if
end function

lo que hace esta función es analizar los dos valores enteros que entraron (aL y bL) y devuelve en el nombre el mayor valor entre ellos (por eso la función se llama mayor). Noten que les agregué una L a las variables, esto es una forma elegante de evitar un efecto similar a la contaminación cruzada en la cocina, conocido como efecto lateral (si se usan los mismos nombres que en el programa, una memoria en mal estado podría asignar nuevas direcciones a la variable original). La forma de invocarla sería:

variable=mayor(x,y)

donde x e y son valores enteros.

Como dije antes, las subroutines (subrutinas en castellano) son solo un poco distintas, en el sentido de que NO devuelven un valor en el nombre, sino que su invocación se hace por medio de la sentencia call. La forma en que trabajan las subrutinas nos permite modificar los valores que entraron como argumentos, siendo esta su característica más importante. Esta es la estructura:

program programa_muestra
... sentencias e invocaciones de la surutina
end program

subroutine nombre_subrutina(argumentos)
declaración de tipo de los argumentos
sentencias sobre los argumentos
end subroutine

nuevamente declaramos los tipos en el subprograma, con mayor razón por que esta vez trabajamos sobre ellos, un ejemplo similar al anterior es:

subroutine mayor(aL,bL)
integer::aL,bL
if (aL .ge. bL) then
bL=aL
else
aL=bL
end if
end subroutine

esta vez, dejamos ambos valores iguales, pero solo tomamos el mayor. La invocamos con:

call mayor(x,y)

donde nuevamente x e y son nuestras variables enteras.

Una pequeña observación con respecto a las subrutinas y funciones, es que los argumentos que toman los subprogramas con los que se declaran dentro del propio subprograma son relaciones uno a uno (inyectivas como decimos en matemáticas), que las variables deben conservar el orden deseado y del mismo tipo que se declararon, ya que si no se producen errores. Un ejemplo “gráfico” es:

donde la segunda llamada a la subrutina obviamente generará error. Amigos, este es el penúltimo post relacionado con Fortran, el próximo es sobre arrays y después de eso dejaría de ser programación para newbies porque ya deberían estar bien introducidos dentro del lenguaje xD

Tweet