Programación Para Newbies: Fortran 5: Subprogramas

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

One thought on “Programación Para Newbies: Fortran 5: Subprogramas

  1. gracias por la publicaciones, he tratado de resolver este problema pero lo que pasa es que no es para newbies y te pediria de favor si me pudieras echar una mano gracias

    3 EN RAYA
    En una de las variantes del clásico juego “tres en raya” se juega sobre un tablero con nueve puntos conectados vertical y horizontalmente, además de las dos diagonales principales.
    0-0 -0
    I I / I
    0-0 -0
    I I / I
    0-0 -0
    Cada jugador dispone de tres fichas que se van colocando por turnos en posiciones no ocupadas. Un jugador gana si consigue poner sus tres fichas en una misma línea antes que su adversario. Una vez colocadas las fichas, en el caso de no haberse producido la victoria de ningún jugador, está permitido que cada jugador desplace una de sus fichas a una posición contigua libre, respetando los turnos, hasta que venza alguno de los oponentes.
    Se pide un programa codificado en Fortran que permita el desarrollo de este juego a dos usuarios.
    Condiciones:
    1. El programa debe ser genérico en el sentido de poder desarrollarse en un tablero de n x n (“n en raya”). Con tan sólo modificar el valor de una constante (en el caso del “3 en raya” el valor de la constante es 3).
    2. El programa debe estar bien estructurado mediante el uso de subprogramas (funciones y subrutinas).
    3. El código debe ser totalmente original pudiendo exigirse al alumno mostrar ante la presencia de profesores que es capaz de subsanar o modificar el código con soltura.
    4. Las jugadas se mostrarán por pantalla y cada jugada se indicará en forma de coordenadas. Por ejemplo, si se están colocando fichas en un tablero de 3 x 3 la introducción por teclado de 2 2 indicaría la posición central (2ª fila 2ª columna), en el caso de que sea un movimiento habrá que indicar la posición de la ficha a mover y su destino.
    5. Además de estar el código comentado debe controlar jugadas imposibles de realizar de acuerdo con las reglas del juego. Obligando al jugador a repetir la jugada en caso de no ser correcta.

    Me gusta

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s