1) Fazer um programa que receba um tempo decorrido em segundos e os transforma em um tempo decorrido em horas minutos e segundos (HH:MM:SS), e, vice-versa.
2) Faça um programa que leia um número com duas casas decimais e o converte no formato de impressão nnn.nnn,nn. E vice-versa.
Nos subconjuntos anteriores F90/1 e F90/2 aprendemos a escrever programas Fortran utilizando comandos organizados de uma maneira chamada de “estrutura seqüencial”, que faziam o computador:
a) Ler valores e atribuir estes valores às variáveis:
READ (*, *) RAIO, ALTURA
b) Avaliar expressões aritméticas e atribuir valores às variáveis:
VOLUME = 3.1416 * RAIO ** 2 ALTURA
c) Imprimir resultados com identificação:
WRITE (*, *) “VOLUME DO CILINDRO = ”, VOLUME
Nestes programas, os comandos eram executados em seqüência até o comando STOP, colocado no final, a ser atingido. Neste ponto, a execução do programa se encerrava.
Aqui, no F90/3, aprenderemos duas maneiras pelas quais a seqüência do programa pode ser alterada. Uma delas envolve o uso caminhos alternativos no fluxo do programa, a outra, envolve repetição de um conjunto de comandos. A primeira maneira é chamada de “estrutura ou comando de desvio ou seleção”, a segunda, é chamada de “estruturas ou comandos de repetição”.
Vamos aprender agora as estruturas que modificam a seqüência normal da execução de um programa. Estas são as estruturas de desvio ou seleção. Temos como estruturas de desvio, o comando IF nas suas formas simples e composta. Antes deste comando ser apresentado, vamos aprender o conceito de expressões lógicas que são a base para a representação de condições, utilizadas no comandos IF.
Expressões Lógicas são constantes ou variáveis do tipo LOGICAL, ou ainda, constantes, variáveis ou expressões aritméticas dos tipos inteiro ou real, ligadas entre si através de operadores lógicos, e que assumem apenas dois valores: VERDADEIRO (.TRUE.) ou FALSO (.FALSE.).
|
Operador |
Relação |
|
.EQ. ou == |
Igual a |
|
.NE. ou /= |
Diferente de |
|
.LT. ou < |
Menor que |
|
.LE. ou <= |
Menor ou igual a |
|
.GT. ou > |
Maior que |
|
.GE. ou >= |
Maior ou igual a |
|
.AND. |
E |
|
.OR. |
Ou |
|
.NOT. |
Não |
Vejamos então exemplos de expressões lógicas.
EXPRESSÃO LÓGICA VALOR LÓGICO
5.0 == 2 + 3 VERDADEIRO
7 .GT. 2 VERDADEIRO
2 .LT. 6 * 5 VERDADEIRO
5 + 3 <= 2 + 1 FALSO
6 .NE. 6.0 FALSO
5 .GT. 5 FALSO
PI * 2 /= 2 * PI FALSO
Podemos ter ainda expressões lógicas compostas, que são expressões lógicas simples ligadas entre si através dos operadores .AND. e .OR.. As tabelas verdade para estes operadores são:
|
.AND. |
V |
F |
|
V |
V |
F |
|
F |
F |
F |
|
.OR. |
V |
F |
|
V |
V |
V |
|
F |
V |
F |
EXPRESSÃO LÓGICA COMPOSTA VALOR LÓGICO
(8 > 7) .AND. (2 == l + l) VERDADEIRO
(6 > 3) .OR. (5 <= 3) VERDADEIRO
(3 /= l + 2) .AND. (3 + 3 > 25.) FALSO
(3 + 5 >= 10) .OR. (55 == 5.5) FALSO
O comando IF possui dois formatos e possibilita que um conjunto de comandos seja ou não executado a partir do valor, VERDADEIRO ou FALSO, de uma condição.
Formatos:
IF (<condição>) THEN
<comando(s) a executar, caso a condição seja VERDADEIRA>
END IF
ou
IF (<condição>) THEN
<comando(s) a executar, caso a condição seja VERDADEIRA>
ELSE
<comando(s) a executar, caso a condição seja FALSA>
END IF
Para o primeiro formato, se a <condição> for VERDADEIRA, o conjunto de comandos entre a cláusula THEN e o END IF são executados e o controle passa para o comando após o END IF; caso contrário, o controle passa diretamente para o comando após o END IF.
Para o segundo formato, se a <condição> é VERDADEIRA, o conjunto de comandos entre a cláusula THEN e o ELSE é executado; caso contrário, se a <condição> é FALSA, o conjunto de comandos entre a cláusula ELSE e o END IF é executado. Em qualquer caso o controle passa para o comando que segue a declaração END IF. Qualquer comando (inclusive outro IF) pode fazer parte dos comandos internos ao IF.
Vejamos um exemplo em Fortran: programa para calcular a média aritmética de 3 notas de um aluno e dar uma mensagem caso ele não tenha atingido a média 7 ou outra maior.
PROGRAM MEDIA1
IMPLICIT NONE
REAL :: NOTA1,
NOTA2, NOTA3, MEDIA
WRITE (*, *) "Executa o cálculo da
média de um aluno:"
WRITE (*, *) "Informe as três notas do
aluno: "
READ (*, *) NOTA1, NOTA2, NOTA3
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3
WRITE (*, *) "MÉDIA DO ALUNO = ", MEDIA
IF (MEDIA .LT. 7.0)
THEN
WRITE (*, *) "ALUNO NÃO OBTEVE MÉDIA
SUFICIENTE!"
END IF
STOP
END PROGRAM MEDIA1
Neste exemplo vimos um IF sem a parte opcional ELSE. Suponha que no exemplo anterior estivéssemos interessados em emitir mensagens informando se o aluno foi reprovado ou aprovado. Logo, a nova versão do programa, com o comando IF com o ELSE, seria:
Programa que avalia o voto de uma pessoa em uma eleição onde o voto é lido através do teclado. Se o valor lido for 0, então o voto será branco; se o valor lido for 1, o voto será do partido da situação; e se 2, o voto será do partido de oposição. Qualquer outro número, consideraremos um voto nulo. A saída do programa deve ser uma mensagem mostrando, por extenso, o voto do eleitor.
VOTO
DO ELEITOR:
O
eleitor votou em BRANCO! ou
O
eleitor votou na SITUAÇÃO! ou
O
eleitor votou na OPOSIÇAO ou
O
voto do eleitor foi NULO!
PROGRAM ELEICAO
IMPLICIT
NONE
INTEGER :: VOTO
WRITE (*,
*) "ELEITOR, INFORME O CÓDIGO DO SEU VOTO: "
WRITE (*,
*) " 0
- BRANCO"
WRITE (*,
*) " 1
- SITUAÇÃO"
WRITE (*,
*) " 2
- OPOSIÇAO"
WRITE (*,
*) " UM
CÓDIGO DIFERENTE DOS LISTADOS, &
&SERÁ CONSIDERADO VOTO NULO:"
READ (*, *)
VOTO
WRITE(*, *)
WRITE(*, *) "VOTO DO ELEITOR:"
IF (VOTO ==
0) THEN
WRITE(*, *) "O eleitor votou em BRANCO!"
ELSE
IF (VOTO
== 1) THEN
WRITE(*, *) "O eleitor votou na SITUAÇÃO!"
ELSE
IF
(VOTO == 2) THEN
WRITE(*, *) "O eleitor votou na OPOSIÇÃO!"
ELSE
WRITE(*, *) "O voto do eleitor foi NULO!"
END IF
ENDIF
END IF
STOP
END PROGRAM ELEICAO
Outro exemplo que utiliza IFs aninhados está no programa que calcula a média final ponderada de um aluno e atribui-lhe um conceito correspondente. As notas serão lidas do teclado: média de minites (peso 3), media de trabalhos (peso 2) e média das provas (peso 5). Se a média final for entre 8,0 e 10,0, o conceito será A; se a média final for maior ou igual a 7,0 e menor que 8,0, o conceito será B; se a média final for maior ou igual a 6,0 e menor que 7,0, o conceito será C; se a média final for maior ou igual a 5,0 e menor que 6,0, o conceito será D; e, se a média final for menor que 5,0, o conceito será E. A saída do programa deve conter a média final e o conceito obtido pelo aluno.
MÉDIA
FINAL DO ALUNO = 99.9
O
ALUNO OBTEVE CONCEITO = X!
PROGRAM CONCEITO
IMPLICIT
NONE
REAL :: MINITESTES, TRABALHOS, PROVAS, MEDIA_FINAL
WRITE (*,
*) "INFORME A MEDIA DOS MINITESTES DO ALUNO:"
READ (*, *)
MINITESTES
WRITE (*,
*) "INFORME A MEDIA DOS TRABALHOS DO ALUNO:"
READ (*, *)
TRABALHOS
WRITE (*,
*) "INFORME A MEDIA DAS PROVAS DO ALUNO:"
READ (*, *)
PROVAS
MEDIA_FINAL
= (3 * MINITESTES + 2 * TRABALHOS + 5 * PROVAS) / 10
WRITE(*, *)
WRITE(*,'(A30,F5.1)') "MEDIA FINAL DO ALUNO =",
MEDIA_FINAL
IF
(MEDIA_FINAL >= 8.0) THEN
WRITE(*, *) "O ALUNO OBTEVE CONCEITO = A!"
ELSE IF (MEDIA_FINAL >= 7.0) THEN
WRITE(*, *) "O
ALUNO OBTEVE CONCEITO = B!"
ELSE IF (MEDIA_FINAL >= 6.0) THEN
WRITE(*, *) "O ALUNO OBTEVE CONCEITO = C!"
ELSE IF (MEDIA_FINAL >=
5.0) THEN
WRITE(*, *) "O
ALUNO OBTEVE CONCEITO = D!"
ELSE
WRITE(*,
*) "O ALUNO OBTEVE CONCEITO = E!"
END IF
STOP
END PROGRAM CONCEITO
CONVERSÃO DE PSEUDOCÓDIGO EM UM PROGRAMA
Algoritmo 5 - Verificar se três lados
formam um triângulo e que tipo de triângulo
algoritmo
/*
Declaração de variáveis */
variáveis
reais: lado1, lado2,
lado3
/*
Obtenção dos dados */
leia lado1, lado2, lado3
/*
Testa se é triângulo */
se (lado1 < lado2+lado3) e (lado2
< lado1+lado3) e
(lado3 < lado2+lado1) então
escreva "Os valores fornecidos formam um
triângulo ",
/* Testa se é eqüilátero */
se (lado1 = lado2) e (lado2 = lado3) então
escreva " eqüilátero."
/*
Testa se é isósceles */
senão se
(lado1 = lado2) ou (lado2 = lado3) ou (lado1 = lado3) então
escreva "isósceles"
senão /* É escaleno */
escreva " escaleno"
senão
escreva "Os valores fornecidos não
formam um triângulo",
fim
se
fim algoritmo
Tomemos o programa que calcula a média de notas numa disciplina de um aluno qualquer:
PROGRAM
MEDIA3_1
IMPLICIT NONE
REAL :: NOTA1,
NOTA2, NOTA3, MEDIA
WRITE (*, *) "Este programa calcula a
média aritmética de &
&3
notas de um aluno"
WRITE (*, *) "Informe as 3 notas do aluno, separadas &
&por brancos: "
READ (*, *) NOTA1, NOTA2, NOTA3
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO NA
DISCIPLINA: ", NOTA1, ", ", &
&NOTA2, "
e ", NOTA3
WRITE (*, *) "MÉDIA NA DISCIPLINA = ", MEDIA
STOP
END
PROGRAM MEDIA3_1
Se tivéssemos apenas um aluno para calcular a média na disciplina, este seria o programa.
Admitamos agora que quiséssemos calcular a média na disciplina para 10 alunos. Teríamos então um programa idêntico ao anterior, com a diferença que o conjunto de comandos:
WRITE (*, *) "Informe as 3 notas do aluno, separadas &
&por brancos: "
READ (*, *) NOTA1, NOTA2, NOTA3
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO NA
DISCIPLINA: ", NOTA1, ", ", &
&NOTA2, "
e ", NOTA3
WRITE (*, *) "MÉDIA NA DISCIPLINA = ", MEDIA
apareceria 10 vezes no programa, uma vez para cada aluno.
Entretanto, existem em Fortran, dois comandos que fazem com que um conjunto de comandos seja repetido automaticamente, tantas vezes quantas necessárias. Estes comandos são: o comando DO e o comando DO WHILE.
Formato:
DO <contador> = <valor inicial>, <valor final>, <incremento>
<comandos a serem repetidos> ou <corpo do DO>
END DO
Os valores: <valor inicial>, <valor final> e <incremento> são variáveis, expressões aritméticas ou constantes. O <incremento> é opcional e sua ausência define o valor 1 para ser adicionado à variável <contador>.
A variável de controle <contador> é uma variável numérica (inteira ou real) que é responsável pela quantidade de vezes que o conjunto de comandos pertencentes ao <corpo do DO> deve ser repetido. <valor inicial> é o primeiro valor após o sinal de igual e define o valor com que a variável de controle <contador> é inicializada. O <valor final> é o segundo valor, e define o valor limite que a variável de controle pode assumir, permitindo ainda a execução dos comandos do <corpo do DO>. O <incremento> é o terceiro número e define o valor que será adicionado à variável de controle <contador> após cada repetição ser executada.
Passo 1: É atribuído o <valor inicial> ao <contador>;
Passo 2: É executado o teste para verificar se o valor de <contador> ultrapassou o <valor final>; se o <contador> não ultrapassou o <valor final> então a execução continua no passo 3, caso contrário, o comando DO é terminado e a execução do programa continua no comando seguinte ao END DO;
Passo 3: Executa os comandos que formam o <corpo do DO>;
Passo 4: Ao atingir a declaração END DO, adiciona à variável <contador> o valor de <incremento> e retorna ao passo 2;
Portanto, para o exemplo citado anteriormente, usaremos o comando DO ao invés de repetir o conjunto de comandos 10 vezes:
PROGRAM MEDIA3_2
IMPLICIT NONE
INTEGER :: VEZES
REAL
:: NOTA1, NOTA2, NOTA3, MEDIA
WRITE (*, *) "Este programa calcula a média
aritmética de &
&3 notas de dez alunos:"
DO
VEZES = 1, 10
WRITE (*, *) "Informe as 3 notas do aluno, separadas &
&por
brancos: "
READ (*, *) NOTA1, NOTA2, NOTA3
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO NA DISCIPLINA: ", NOTA1, ",
", &
&NOTA2, " e
", NOTA3
WRITE (*, *) "MÉDIA NA DISCIPLINA = ", MEDIA
END
DO
STOP
END PROGRAM MEDIA3_2
1) O comando DO é sempre usado quando sabemos exatamente o número de vezes que um conjunto de comandos deve ser repetido. A variável <contador> pode ser inteira ou real. Podemos utilizar quaisquer valores numéricos, inteiros ou reais (variáveis, constantes ou expressões aritméticas), para definir <valor inicial>, <valor final> e <incremento>. Necessitamos inicializar <contador> com o número 1 e incrementá-lo de 1 em 1 até o valor do número de repetições. Podemos ter por exemplo:
DO I
= 1, 10, 1
READ (*, *) NOTAl,
NOTA2, NOTA3
MEDIA = (NOTAl +
NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO:"
WRITE (*, *) NOTA1, NOTA2, NOTA3
WRITE (*, *) "MEDIA DO CURSO"
WRITE (*, *) MEDIA
END
DO
O importante é que nós sabemos com certeza que este conjunto de comandos, dentro do ciclo de repetição DO, será repetido 10 vezes.
2) Quando omitimos o incremento de um comando DO, Fortran considera o incremento igual a 1. Exemplo:
DO I = 1, 30 ! é assumido 1 para o incremento
3) Seja o comando
DO I = V1, V2, V3
Pode ocorrer que para uma certa combinação destes valores Vl, V2 e V3, o contador I não atinja o valor exato de V2. Mesmo neste caso, o loop termina quando I atingir um valor maior que V2. Exemplo:
DO I = 1, 6 ,2
4) Os valores de I, V1, V2 e V3 não podem ser alterados dentro do corpo do DO.
5) Após o processamento completo de um DO, o valor do índice da variável de controle estará com o valor que ultrapassou o valor final e pode ser usado no programa.
6) Ninhos de DO´s (DO dentro de DO) - Os DO's externos têm de envolver completamente os DO's mais internos Exemplo:
DO I = 1, 10, 1
DO J =
10, -10, -1
WRITE(*, *) I, J
END DO
END DO
7) Em ninhos de DO´s, o contador do DO mais interno varia seu valores totalmente para cada repetição do DO mais externo.
DO I = 1, 5
DO J =
1, 10
K =
I + J
END DO
WRITE(*, *) K
END DO
Enquanto I do DO externo está com valor 1, no DO interno J varia de 1 a 10; quando J ultrapassa o valor 10, o valor de K é impresso. A seguir I assume o valor 2 enquanto J mais uma vez varia de 1 a 10; e assim por diante. J varia pela última vez de l a 10, quando o valor de I é 5. O laço externo terminará quando I ultrapassar o valor 5.
EXERCÍCIO: Fazer um programa que desenha uma
tabela quadriculada em branco usando um ninho de DOs.
Formato:
DO WHILE (<condição>)
<comandos a serem repetidos> ou <corpo do DO WHILE>
END DO
A <condição> (expressão lógica) é testada antes do início do laço. Se a condição é VERDADEIRA, o conjunto de comandos do <corpo do DO WHILE> é executado e em seguida a condição é novamente testada. Quando a <condição> finalmente tornar-se FALSA, o controle é passado para o próximo comando após o END DO.
Passo 1: Testa a condição; se verdadeira segue para o passo 2; caso contrário termina o laço e o controle passa para o comando que segue o END DO
Passo 2: Executa o <corpo do DO WHILE> e retorna ao passo 1.
Exemplo 1: Então para o exemplo dos 10 alunos poderíamos ter:
PROGRAM MEDIA3_3
IMPLICIT NONE
REAL
:: NOTA1, NOTA2, NOTA3, MEDIA
INTEGER :: CONT
WRITE (*, *) "Este programa calcula a média
aritmética de &
&3 notas para 10 alunos:"
CONT
= 1
DO WHILE (CONT <= 10)
WRITE (*, *) "Informe as 3 notas
do aluno, separadas &
&por
brancos: "
READ (*, *) NOTA1, NOTA2, NOTA3
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO NA
DISCIPLINA: ", NOTA1, ", ", &
& NOTA2, " e
", NOTA3
WRITE (*, *) "MÉDIA NA DISCIPLINA
= ", MEDIA
CONT = CONT + 1
END DO
STOP
END
PROGRAM MEDIA3_3
Este exemplo, é mais indicado para o comando DO porque sabemos que o conjunto de comandos deve ser repetido exatamente 10 vezes. Nós usamos o comando DO WHILE quando não sabemos exatamente o número de vezes que o conjunto de comandos deve ser executado, mas sabemos; que deve ser executado enquanto a <condição> for VERDADEIRA.
Exemplo 2: Suponha que desconhecemos o número de alunos da turma mas sabemos que todas as notas são maiores ou iguais a 0. Então colocamos um FLAG (marca) no final dos dados para determinar o final das entradas. Este FLAG pode ser uma variável só para determinar o final (flag explícito) ou um valor especial de um dado de entrada (flag implícito). Vejamos o FLAG com uma nota negativa, que indicará ao programa o fim dos dados (fim de arquivo). O programa será o seguinte:
PROGRAM MEDIA3_4
IMPLICIT NONE
REAL
:: NOTA1, NOTA2, NOTA3, MEDIA
WRITE (*, *) "Este programa calcula a média
aritmética de &
&3 notas de vários alunos até encontrar uma nota negativa:"
WRITE (*, *) "Informe as 3 notas do aluno, separadas &
&por
brancos: "
READ
(*, *) NOTA1, NOTA2, NOTA3
DO
WHILE (NOTA1 >= 0 .AND. NOTA2 >= 0 .AND. NOTA3 >= 0)
MEDIA = (NOTA1 + NOTA2 + NOTA3) / 3.
WRITE (*, *) "NOTAS DO ALUNO NA DISCIPLINA: ", NOTA1, ",
",&
& NOTA2, " e
", NOTA3
WRITE (*, *) "MÉDIA NA DISCIPLINA = ", MEDIA
WRITE (*, *) "Informe as 3 notas do aluno, separadas &
&por
brancos: "
READ (*, *) NOTA1, NOTA2, NOTA3
END
DO
STOP
END PROGRAM MEDIA3_4
EXERCÍCIO: Refazer o programa acima com um flag explícito.
Exemplo 3: Programa para calcular o fatorial de vários números até que seja lido um valor negativo (flag):
! PROGRAMA PARA CALCULAR O FATORIAL DE VÁRIOS
NÚMEROS LIDOS ATÉ
! QUE SEJA LIDO UM VALOR NEGATIVO (FLAG)
PROGRAM FATORIAL_VARIOS
IMPLICIT NONE
INTEGER :: NUMERO, FATOR, FATORIAL
WRITE(*, *) "CÁLCULO DO FATORIAL DE VÁRIOS
NÚMEROS:"
WRITE(*, *)
WRITE(*, *) "INFORME O NÚMERO PARA O CÁLCULO DO
FATORIAL OU "
WRITE(*, *) "UM NÚMERO NEGATIVO PARA ENCERRAR O
PROGRAMA: "
READ
(*, *) NUMERO
DO
WHILE (NUMERO >= 0)
FATORIAL = 1
DO FATOR = 1, NUMERO, 1
FATORIAL = FATORIAL * FATOR
END DO
WRITE(*, *) "O FATORIAL DE ", NUMERO, " É
", FATORIAL
WRITE(*, *)
WRITE(*, *) "INFORME O NÚMERO PARA O CÁLCULO DO
FATORIAL OU "
WRITE(*, *) "UM NÚMERO NEGATIVO PARA ENCERRAR O
PROGRAMA: "
READ (*, *) NUMERO
END
DO
STOP
END PROGRAM FATORIAL_VARIOS
Quando usamos o comando DO WHILE precisamos ter cuidado para o laço não torna-se infinito. Para evitar isto é necessário:
1) Alterar o valor da variável envolvida na condição dentro do corpo do laço.
2) Certificar-se que a condição de fim de laço será atingida.
Existem, duas maneiras, de rotular a saída de resultados num programa. A primeira delas já vista nos capítulos anteriores. Por exemplo, se nosso programa calcula o volume de uma caixa, então, o rótulo de saída no comando PRINT é:
WRITE (*, *) “VOLUME DA CAIXA = ”, VOLUME
Onde, a constante literal “VOLUME DA CAIXA = “, rotula, ou seja, explica exatamente o significado do conteúdo do valor que está sendo mostrado.
A outra maneira acontece quando um conjunto de variáveis devem ser listadas, em colunas, na saída do programa como no exemplo a seguir.
Programa que imprime uma tabela das funções Y e Z para valores de X = 0.5, 1.0, l.5, ... , 5.0, sendo:
y = ln(x) è função logarítmica
z = ex è função exponencial
O rótulo da saída deve ser:
FUNÇÃO FUNÇÃO
VALOR DE X LOGARITMICA EXPONENCIAL
0.5000000E00 -0.6931472E00 0.1648721e01
0.1000000E01 . .
0.1500000E01 . .
. . .
.
.
0.5000000E01
Sabemos que uma variável inteira ocupa um campo de 12 posições na impressão enquanto que uma variável real ocupa 14 posições. Se as variáveis X, Y e Z são todas reais, então cada uma delas vai ocupar 14 posições na impressão, portanto o rótulo de cada variável deve ocupar também, 14 posições para que o rótulo fique exatamente sobre a variável que ele vai identificar (explicar), seja, por exemplo:
“ VALOR DE X ”, deve ficar na coluna que X será mostrada;
“ FUNÇÃO ”
“ LOGARÍTMICA ”, deve ficar na coluna que Y será mostrada;
“ FUNÇÃO ”
“ EXPONENCIAL ”, deve ficar na coluna que X será mostrada.
O programa ,será então:
! PROGRAMA QUE CALCULA AS FUNÇÕES LOGARÍTMQ E
EXPONENCIAL PARA
! VALORES DE X = 0.5, 1.0, 1.5, ... , 5,0
PROGRAM CALCULA_FUNCOES
IMPLICIT NONE
INTEGER :: I
REAL
:: X, FUNLOG, FUNEXP
WRITE (*, *) "
", " FUNÇÃO ", " FUNÇÃO
"
WRITE (*, *) " VALOR DE X
", " LOGARITMICA ",
" EXPONENCIAL
"
X = 0
DO I
= 1, 10
X
= X + 0.5
FUNLOG = ALOG(X)
FUNEXP = EXP(X)
WRITE (*, *) X, FUNLOG, FUNEXP
END
DO
STOP
END PROGRAM CALCULA_FUNCOES
1. Fazer um programa Fortran que recebe uma lista de preços de 3 supermercados (como a da planilha) e no final informa o supermercado mais barato.
PRIMEIRO NÍVEL DO PSEUDOCÓDIGO
Definir as variáveis
Escrever o cabeçalho
Zerar três acumuladores, um para cada supermercado
Determinar a forma do FLAG
Enquanto o flag for verdadeiro:
Ler uma linha (nome_do_produto, quantidade e três preços unitários), e acumular os preços calculados nos três acumuladores;
2. Determinar o melhor supermercado e informar o resultado.
3. Suponha que você dispõe de R$ 150.000, guardados para utilizar numa eventual emergência. Assumindo uma inflação de 15% ao ano, escreva um programa Fortran que imprima a cada ano, durante 8 anos, a quantia em real que você deverá ter para manter sempre o equivalente deste dinheiro guardado.
4. Fazer um programa Fortran que imprima uma tabela da função y para valores de x = 0.1, 0.2,..., 1.0 sendo:
10
y = å x3
n=l N! ou seja,
y = x3 + x3 +
...+ x3
1! 2! n!
onde n! 1 x 2 x 3 x...x n fatorial de n-l.
5. Fazer um programa Fortran que calcula e mostra as raízes de 15 equações do 2o. grau, lendo os coeficientes de cada equação através do teclado.
Fórmula:
D = delta = b2 – 4ac
D < 0 è não pode calcular raiz; mostrar mensagem dizendo delta é negativo e mostrar este valor.
D = 0 è raiz = -b/2a
____ ____
D
> 0 è
raizl = -b
+ Ödelta
raiz2 = +b + Ödelta
2a 2a
6. Fazer um programa Fortran que mostre o conjunto dos números pares positivos até o 15o. termo e o conjunto dos números ímpares positivos até o 20o. termo.
OBS. Comentar todos os programas.