##############################################################################

FÍSICA COMPUTACIONAL I: EXEMPLOS ENVOLVENDO OS COMANDOS DO E IF E 
                        VARIÁVEIS INDEXADAS

##############################################################################

Um exemplo simples do uso da estrutura DO-ENDDO que imprime mil vezes a
palavra "oi":
   
           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x
           do x=1,100,1
              print *,"oi"
           enddo
           stop
           end

Os números inteiros que controlam o comando DO podem ser variáveis inteiras:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,xi,xf,incr
           xi=1
           xf=1000
           incr=1
           do x=xi,xf,incr
              print *,"oi"
           enddo
           stop
           end

sendo que eles podem ter quaisquer valores positivos ou negativos, desde que
haja consistência interna: deve ser possível sair do início e chegar ao
final usando o incremento declarado.

Uma operação impossível é a alteração da variável de controle do laço DO,
dentro do próprio laço:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,xi,xf,incr
           xi=1
           xf=1000
           incr=1
           do x=xi,xf,incr
              print *,"oi"
              x=x+2 <=== ERRO!
           enddo
           stop
           end

O número de comandos dentro da estrutura DO-ENDDO é ilimitado:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,xi,xf,incr
           xi=1
           xf=1000
           incr=1
           do x=xi,xf,incr
              print *,"oi"
              print *,"como vais?"
              print *,"como foi o resultado do jogo ontem?"
              print *,"nao sei pois nao vi o jogo."
           enddo
           stop
           end

Uma característica extremamente importante: a variável de controle pode ser
usada para operações matemáticas, embora seja proibido alterar o seu valor
dentro do laço:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,soma,n
           print *,"Digite o valor de N?"
           read *,n
           soma=0
           do x=1,n,1
              soma=soma+x
           enddo
           print *,"a soma de 1 ate N eh: ",soma
           stop
           end

Variáveis indexadas são variáveis com mesmo nome somente diferenciadas pelos
valores de seus indíces:


           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer soma
           integer a(-1:2)
           a(-1)=15
           a(1)=12
           a(0)=3
           a(2)=21
           soma=a(2)+a(1)+a(0)+a(-1)
           print *,soma
           stop
           end

No exemplo abaixo vemos o entrelaçamento da variável de controle do DO com o
índice de uma variável indexada (VI):

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,a
           dimension a(1:10)
           do x=1,10,1
              a(x)=0
              print *,x,a(x)
           enddo
           stop
           end

E pode-se usar a variável de controle para atribuir valores para a VI:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,a
           dimension a(1:10)
           do x=1,10,1
              a(x)=5*x**2-4*x+3
              print *,x,a(x)
           enddo
           stop
           end

O exemplo acima pode ficar mais flexível com o uso dos comandos ALLOCATABLE
e ALLOCATE:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x,n
           integer,dimension(:),allocatable :: a
           print *,"digite o valor de n:"
           read *,n
           allocate(a(1:n))
           do x=1,n,1
              a(x)=5*x**2-4*x+3
              print *,x,a(x)
           enddo
           stop
           end

Podem existir estruturas DO-ENDDO entrelaçadas, que no exemplo abaixo servem
para manipular uma matriz:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x1,x2,l,c
           integer,dimension(:,:),allocatable :: a
           print *,"digite as dimensoes da matriz, linhas e colunas:"
           read *,l,c
           allocate(a(1:l,1:c))
           do x1=1,l,1
             do x2=1,c,1
               a(x1,x2)=5*x1**2-4*x2+3*x1*x2+5
               print *,x1,x2,a(x1,x2)
             enddo ! final do laco de x2
           enddo ! final do laco de x1
           stop
           end

O número de DOs que podem ser encaixados é maior que 2. 

Podem existir inúmeros comandos entre os DOs e ENDDOs:

           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer x1,x2,l,c
           integer,dimension(:,:),allocatable :: a,b
           print *,"digite as dimensoes da matriz, linhas e colunas:"
           read *,l,c
           allocate(a(1:l,1:c))
           do x1=1,l,1
             print *,"calculando os elementos da linha: ",x1
             do x2=1,c,1
               a(x1,x2)=5*x1**2-4*x2+3*x1*x2+5
               print *,x1,x2,a(x1,x2)
             enddo ! final do laco de x2
             print *,"terminou o calculo dos elementos da linha :",x1
           enddo ! final do laco de x1
           stop
           end







Um exercício de cinemática:
   
           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer i
           real x,v,a,t,x0,v0,dt
           a=10
           t=0
           x=0
           x0=0
           v0=20
           dt=0.1
           do i=0,100,1
               t=i*dt
               x=x0+v0*t-0.5*a*t**2
               print *,t,x
           enddo
           stop
           end

O mesmo exercício, melhorado no sentido que controla melhor o número de
laços necessários:
   
           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer i
           real x,v,a,t,x0,v0,dt
           i=0
           a=10
           t=0
           x=0
           x0=0
           v0=20
           dt=0.1
           do while (x>=0)
               t=i*dt
               x=x0+v0*t-0.5*a*t**2
               print *,t,x
               i=i+1
           enddo
           stop
           end

Um IF encaixado em um DO:
   
           program exemplo
   ! Objetivo: exemplo
   ! Programador: FC Lavarda
           implicit none
           integer i,x,soma_negativa,soma_positiva
           i=1
           soma_negativa=0
           soma_positiva=0
           print *,'Digite 10 números inteiros:'
           do i=1,10,1
               read *,x
               if(x<0)then
                 soma_negativa=soma_negativa+x
               else
                 soma_positiva=soma_positiva+x
               endif
           enddo
           stop
           end