program flowControl

!///////////////////////////////////////////////////////////////
!/                 CONTROL DE FLUJO                            /
!/  Este programa ejemplifica el uso de sentencias de control  /
!/  de flujo: Sentencias "Condicionales" y de "bucles" (loops) /
!/                                                             /  
!///////////////////////////////////////////////////////////////

! declaración de variables
 real          :: a,b,c,delta
 integer       :: int,increment





!////////////////////////////////////
!/       SENTENCIA IF-THEN-ELSE     /
!/  IF (condicion) THEN             / 
!/    {bloque de sentencias}        /
!/  ELSE IF (condicion) THEN        /
!/    {bloque de sentencias}        /
!/  ELSE IF (condicion) THEN        /
!/	...                              /
!/	...                              /
!/  ELSE                            /
!/    {bloque de sentencias}        /
!/  END IF                          /
!/                                  /
!////////////////////////////////////

! Ejemplo
 print*
 print*,"---- EJEMPLO DE SENTENCIA IF-THEN-ELSE ----"; print*

 a = 2.0
 b = 3.0
 c = 1.0
 delta = b**2-4*a*c

 print*," Las raices de la ecuación de 2do. grado de coefs.",a,b,c,"son: ";print*

 if ((delta > 0).and.(a /= 0)) then
	x1 = (-b + sqrt(delta))/2*a
	x2 = (-b - sqrt(delta))/2*a
	print*,"x1=",x1,"  x2=",x2
 else if ((delta == 0).and.(a /= 0)) then
	x = -b/2*a
	print*, "x=",x
 else
	print*, "El discriminante es negativo"
 end if





!/////////////////////////////////////////////////////////
!/                 SENTENCIA CASE                        /
!/  La sentencia CASE permite escojer entre un conjunto  /
!/  de casos para una expresion dada. La sintaxis es:    /
!/                                                       /
!/  SELECT CASE (expresion)                              /
!/  CASE (valor1)                                        /
!/     {bloque de sentencias}                            /
!/  ....                                                 /
!/  CASE (valor k)                                       /
!/     {bloque de sentencias}                            /
!/  CASE DEFAULT                                         /
!/     {bloque de sentencias}                            /
!/  END CASE                                             /
!/                                                       /
!/////////////////////////////////////////////////////////

! Ejemplo
print*
print*,"---- EJEMPO DE SENTENCIA CASE ----";print*
print*, "Selecciono entre un conjunto de valores de un expresion aritmetica: 15,20 u otro valor";print*

int = 10
select case (int+10)
case (15)
   print*,"int+10 vale:",int+10
case (20)
   print*,"int+10 vale:",int+10
case default
   print*,"int+10 no es ni 15 ni 20"
end select





!/////////////////////////////////////////////////////////
!/              SENTENCIA DO                             /
!/																			/
!/	Do con un numero fijo de iteraciones:                 /
!/                                                       / 																
!/  DO varInteger = inicio,final,incremento              /
!/      {bloque de sentencias}                           /
!/  END DO                                               /
!/                                                       /
!/                                                       /
!/ Do con un nro. de iteraciones dado por una condicion: /
!/                                                       /
!/ DO	WHILE (condicion)                                  /
!/   {bloque de sentencias}                              /
!/ END DO                                                /
!/                                                       /
!///////////////////////////////////////////////////////// 		

! Ejemplos de Sentencia DO con nro.fijo de iteraciones
! La variable int que recorre el rango de las iteraciónes, se puede usar
! en el cuerpo del do, pero no modificarse.

! Uso un incremento negativo de valor -2:
print*;print*
print*,"---- EJEMPLO DE SENTENCIA CON UN NRO. FIJO DE ITERACIONES ----";print*
print*," Decremento int desde 10 hasta cero de a 2:";print*

increment = -2
do int = 10,0,increment
   print*, "int=",int
end do


! Ejemplo de sentencia DO WHILE 
! Decremento int desde 10 mientras que int sea mayor que la raiz cuadrada
! de 2*int
print*;print*
print*, "---- EJEMPLO DE SENTENCIA DO WHILE ----";print*
print*, "Decremento int comenzando por 10, mientras sea mayor que sqrt(2*int): ";print*;print*

int = 10
do while (int > sqrt(2.0*int))
   print*, "int=",int
   int = int -1 
end do

! El comando do tambien es valido de la siguiente forma:
!            DO 
!              {bloque de sentencias}
!            END DO
!
! Ejemplos:
print*
print*,"---- EJEMPLO DE SENTENCIA DO simple ----";print*
print*," int vale inicialmente 10, lo imprimo hasta que valga menos que 5:"

int = 10
do
   !El cojunto de sentencias siguientes se ejecuta al menos 1 vez antes de 
   ! alcanzar el if:
   print*, "int vale:",int
   int = int - 1
      
   !Impongo una condicion para salir del loop, EXIT sale del loop
   if (int < 5 ) then
      print*,"int es menor que cinco, salgo del loop"
      EXIT
   end if

   !Si la condicion del if es falsa, sigue y ejecuta el conjunto final
   !de sentencias y pasa a la iteracion siguiente
   print*,"Pase el if, sigo iterando..."
end do

end program flowControl