[8. La sentencia if ]  [Tutorial de Fortran]  [10. Arreglos ]

9. Ciclos

Para la repetir la ejecución de sentencias se usan los ciclos. Si se esta familiarizado con otros lenguajes de programación se habrá escuchado de los ciclos-for y de los ciclos-until, Fortran 77 tiene solamente una construcción de ciclo, conocida como el ciclodo. El ciclo-do corresponde al ciclo-for que existe en otros lenguajes de programación. Otros ciclos pueden ser simulados usando las sentencias if y goto.

Ciclos-do

El ciclo-do es usado para repetir un conjunto de sentencias una determinada cantidad de veces. Se muestra el siguiente ejemplo donde se calcula la suma de los enteros desde el 1 hasta n (suponiendo que a n se le ha asignado un valor previamente): 
      integer i, n, suma
      :
      :
      :
      suma = 0
      do 10 i = 1, n
         suma = suma + i
         write(*,*) 'i =', i
         write(*,*) 'suma =', suma
   10 continue
El número 10 es una sentencia de etiqueta. Típicamente, podría haber varios ciclos y otras sentencias en un programa que requierean una sentencia de etiqueta. El programador es responsable de asignar un número único a cada etiqueta en cada programa (o subprograma). Recordar que las posiciones de las columnas 2-5 son reservadas para sentencias de etiquetas. El valor numérico de las sentencias de etiqueta no tienen ningún significado, por lo que cualquier valor entero puede ser usado. Por lo general, los programadores incrementan las etiquetas de 10 en 10 cada vez.

La variable en la sentencia do es incrementada en 1 por default. Sin embargo, se puede usar cualquier otro entero para el paso o incremento. El siguiente segmento de programa muestra los números pares en forma decreciente entre el 1 y 10: 

      integer i

      do 20 i = 10, 1, -2
         write(*,*) 'i =', i
   20 continue

La forma general del ciclo do es la siguiente: 

      do etiqueta  var =  expr1, expr2, expr3
         sentencias
 etiq continue
donde:
var es la variable del ciclo (conocida con frecuencia como el índice del ciclo) el cual deberá ser del tipo integer.
expr1 indica el valor inicial de var,
expr2 es el valor hasta el que llegará el índice, y
expr3 es el incremento (step).

Nota: La variable del ciclo do nunca deberá ser modificada por otras sentencias dentro del ciclo, ya que puede generar errores de lógica.

Muchos compiladores de Fortran 77 permiten que los ciclos do sean cerrados por la sentencia enddo. La ventaja es que la sentencia etiqueta puede ser omitida, ya que en este caso la sentencia enddo cierra la sentencia do más cercana. La construcción enddo es ampliamente usada, pero no es parte del ANSI Fortran 77.

Ciclos while

La forma más intuitiva para escribir un ciclo while es 
      while (expr lógica) do
         sentencias
      enddo
o de forma alterna 
      do while (expr lógica) 
         sentencias
      enddo
Las sentencias en el cuerpo serán repetidas mientras la condición en el ciclo while sea verdadera. A pesar de que esta sintaxis es aceptada por muchos compiladores (incluyendo el de Linux), no forma parte del ANSI Fortran 77. La forma correcta es usando las sentencias if y goto: 
 etiq if (expr lógica) then
         sentencias
         goto etiq
      endif

A continuación se tiene un ejemplo que calcula y muestra el doble de todos los número anterior comenzando con el 2 y que son menores a 100: 

      integer n
      n = 1
   10 if (n .lt. 100) then
         n = 2*n
         write (*,*) n
         goto 10
      endif

Ciclos-until

Es un ciclo el cual el criterio de terminación esta al final en vez del inicio. En pseudocódigo tendríamos el siguiente formato: 
      haz
         sentencias
      hasta (expr lógica)
lo cual nuevamente, puede ser implementado en Fortran 77 usando las sentencias if y goto: 
 etiq continue
         sentencias
      if (expr lógica) goto etiq
Observar que la expresión lógica en la última versión deberá ser la negación de la expresión dada en pseudocódigo.

Ciclos en Fortran 90

Fortran 90 ha adoptado la construcción do-enddo como su ciclo ( el f77 de linux la reconoce como válida). Por lo que el ejemplo de decrementar de dos en dos queda como: 
      do i = 10, 1, -2
         write(*,*) 'i =', i
      enddo
para simular los ciclos while y until se puede usar la construcción do-enddo, pero se tiene que agregar una sentencia condicional de salida exit (salida). El caso general es: 
      do
         sentencias
         if (expr lógica) exit
         sentencias
      end do
Si se tienen la condición de salida al principio es un ciclo while, y si esta al final se tiene un ciclo until.

Ejercicios

Ejercicio a
Reescribe los siguientes pseudocódigos en código de Fortran 77. Evitar usar la sentencia goto si es posible. 
i = 1
mientras (i<100) haz
   suma = suma + i
   i = i+2
fin_mientras
i = 0
x = 1.0
repite
   x = f(x)
   i = i+1
hasta que (x<0)
muestra i, x

Ejercicio B
El siguiente código esta pobremente escrito. Reescribelos con un buen estilo para F77. (Tip: Compila y ejecuta el programa para verificar que la nueva versión da el mismo resultado versión anterior. El compilador mandará algunos "warnings" por el espaguetti que se hace con el código.) 
      i = 1
      suma = 0
   10 do 20 i = 1, 50
         if (i .gt. 10) goto 30
         suma = suma + i
   20 continue
   30 if (i .le. 20) then
         suma = suma - 1
         goto 20
      else
         suma = 2*suma
      endif
      write(*,*) 'Suma =', suma
 [8. La sentencia if ]  [Tutorial de Fortran]  [10. Arreglos ]