Escolar Documentos
Profissional Documentos
Cultura Documentos
Fortran 90 Completa PDF
Fortran 90 Completa PDF
INTRODUÇÃO
OBJETIVOS DO CAPÍTULO
• Conceitos de: linguagem de programação, FORTRAN, projeto, programa-fonte, programa-objeto,
programa-executável, compilação, comando
• Procedimentos básicos para programar em linguagem FORTRAN
• Comandos do FORTRAN: WRITE e END
1.2 BIBLIOGRAFIA
Não é objetivo deste texto entrar em detalhes sobre hardware e software de computadores. Aos
interessados nestes aspectos recomenda-se o livro de Ramalho (2000), que é adotado neste texto como
referência para termos técnicos de informática em português. Dois textos recomendados sobre algoritmos
são o livro de Forbellone e Eberspacher (2000) e a apostila de Moraes (2000). O material apresentado
aqui é baseado no livro de Adams et al. (1997), que se constitui num manual completo sobre a linguagem
FORTRAN 95, padronizada pelas organizações ISO (International Standadrs Organization) e ANSI
(American National Standards Institute).
Capítulo 1. Introdução 1
1.3 FORTRAN
Existe uma infinidade de linguagens de programação, por exemplo, Assembly, Cobol, Visual
Basic, Pascal, Java, C++ etc (Ramalho, 2000, p. 114 e 124-30). Elas são usadas para criar os programas,
também denominados de softwares ou aplicativos, que são empregados nos computadores. A utilidade
das linguagens de programação pode ser percebida ao se lembrar para que são usados, por exemplo: os
sistemas operacionais Windows, Unix e Linux; os aplicativos Word, Excel, PowerPoint, FrontPage,
CorelDraw, Origin e Acrobat; os navegadores da internet Netscape e Explorer; e os programas dos caixas
automáticos dos bancos.
A linguagem FORTRAN, contração de FORmula TRANslation (Tradução de Fórmulas), ainda é a
principal linguagem de programação usada em engenharia e aplicações científicas (Adams, 2000, p. 1).
Foi criada em 1954. Sua primeira versão comercial surgiu em 1957. As versões do FORTRAN
padronizadas pela ANSI e ISO são:
1) Ano 1966 = FORTRAN 66
2) Ano 1978 = FORTRAN 77
3) Ano 1992 = FORTRAN 90
4) Ano 1997 = FORTRAN 95
1.4 CONVENÇÕES
Capítulo 1. Introdução 2
1.5 INICIALIZAÇÃO DO APLICATIVO FORTRAN POWERSTATION 4.0
Para seguir este texto, não é necessário nenhum conhecimento anterior sobre linguagem de
programação. É necessário apenas ter conhecimentos básicos sobre o sistema operacional Windows NT
4.0 ou versões mais recentes. Todos os programas em FORTRAN apresentados neste texto foram
editados e compilados com o aplicativo Fortran PowerStation 4.0, da Microsoft. Além de seus manuais,
este aplicativo contém o livro de Hahn (1994) sobre FORTRAN 90 e o item Reference onde são descritos
todos os comandos do FORTRAN, incluindo exemplos.
Conforme é mostrado na Figura 1.1, para iniciar o uso deste aplicativo, deve-se executar no
Windows: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio. Para facilitar a
edição dos programas, recomenda-se maximizar a janela principal do Fortran, clicando sobre o ícone
central que fica no canto superior direito. Fazendo isso, o aspecto do Fortran deverá ser semelhante
àquele mostrado na Figura 1.2.
Capítulo 1. Introdução 3
Figura 1.2 Janela principal do aplicativo Fortran PowerStation 4.0.
1) Na barra em azul, o ícone do Fortran e o título da janela principal: Microsoft Developer Studio.
2) Abaixo da barra em azul, o menu do Fortran, ou seja, as opções existentes para usar este aplicativo,
que são: File, Edit, View, Insert, Build, Tools, Window e Help.
3) A janela principal do Fortran é dividida em três partes ou subjanelas. Se não estiver aparecendo a
subjanela inferior, mostrada na Figura 1.2, deve-se executar: View, Output.
4) Na subjanela do lado esquerdo, tem-se o diretório principal dos manuais do Fortran, destacando-se:
Reference, que é uma lista de comandos do FORTRAN 90, incluindo explicações e exemplos de uso;
e Fortran 90 for Scientists and Engineers, que é um livro sobre a linguagem FORTRAN 90. Esta
subjanela também é usada para mostrar os nomes dos programas editados na linguagem FORTRAN.
Quando um programa estiver sendo editado, para acessar os manuais, deve-se clicar sobre a opção ?
InfoView, mostrada na Figura 1.2, que fica na parte inferior da subjanela do lado esquerdo. E para
voltar ao programa que está sendo editado, basta clicar sobre a opção FileView.
5) Na subjanela inferior são apresentadas informações sobre erros de programação e compilação.
Detalhes serão vistos no capítulo 2.
6) A subjanela do lado direito, a maior das três, é usada para: apresentar o conteúdo dos manuais e para a
edição de programas em FORTRAN.
Capítulo 1. Introdução 4
1.6 CRIAÇÃO DE UM PROJETO DO TIPO CONSOLE APPLICATION
O Fortran organiza todos os arquivos de um programa numa entidade chamada projeto. Em termos
práticos, a criação de um projeto resulta na criação de uma pasta ou diretório dentro do Windows.
Existem diversos tipos de projetos que podem ser criados com o Fortran. A escolha do tipo depende da
finalidade do programa e dos recursos do Windows que se deseja empregar. No caso deste texto, em sua
parte básica, que compreende os capítulos 1 a 13, são empregados apenas projetos do tipo Console
Application. E na parte avançada, que corresponde aos capítulos 14 a 20, são usados projetos do tipo
QuickWin Application, que permite utilizar diversos recursos do Windows.
Para criar um projeto do tipo Console Application, devem ser executados os seguintes passos:
1) No menu do Fortran, conforme é mostrado na Figura 1.3: File, New.
2) Na janela New, mostrada na Figura 1.4, clicar sobre a opção Project Workspace. Depois, clicar
sobre o botão OK.
3) Na janela New Project Workspace, mostrada na Figura 1.5, é necessário executar o que segue:
Capítulo 1. Introdução 5
Figura 1.4 Segundo passo na criação de um projeto no Fortran.
a) Entre os seis tipos de projetos apresentados na opção Type, clicar sobre Console Application no
caso deste tipo de projeto não estar selecionado (realçado em azul).
b) Na opção Location estará indicado um diretório (pasta) default, ou seja, um diretório escolhido
pelo próprio Fortran em função de sua configuração atual. É possível que não seja o diretório
desejado. Neste caso, deve-se clicar sobre o botão Browse para indicar o diretório onde se quer
criar o projeto. Ao se fazer isso, surgirá a janela Choose Directory mostrada na Figura 1.6, na qual
deve-se executar:
• Na opção Drives, clicando sobre o triângulo invertido, escolher C:
• Na opção Directory name, digitar C:\MSDEV\Projects, conforme é mostrado na Figura 1.7.
• Clicar sobre o botão OK.
c) Estará de volta a janela New Project Workspace, mostrada na Figura 1.5. Clicar dentro do espaço
de edição da opção Name. Escrever o nome do projeto, por exemplo, programa01. Depois disso,
a janela New Project Workspace deverá ficar conforme a Figura 1.8. Deve-se perceber que o
nome do projeto, digitado na opção Name, aparece automaticamente na opção Location. Em
Capítulo 1. Introdução 6
seguida, deve-se clicar sobre o botão Create. Após isso, o Fortran criará um diretório com o nome
do projeto indicado, dentro do diretório já selecionado, conforme é mostrado na Figura 1.9.
Capítulo 1. Introdução 7
Figura 1.9 Fortran com o nome do diretório criado para o projeto especificado.
Capítulo 1. Introdução 8
Figura 1.10 Início da criação do programa-fonte.
3) Na janela Microsoft Developer Studio, mostrada na Figura 1.13, clicar sobre o botão Yes
4) Na subjanela do lado esquerdo do Fortran, clicar sobre o sinal + ao lado do nome do projeto; deverá
aparecer o nome do programa-fonte que foi inserido no projeto; no caso, programa01.f90
Capítulo 1. Introdução 9
5) Clicar rapidamente duas vezes sobre o nome do programa-fonte que foi inserido
6) Na janela Microsoft Developer Studio, mostrada na Figura 1.14, clicar sobre o botão Yes
7) O programa-fonte inserido no projeto já está pronto para ser editado na subjanela do lado direito do
Fortran, conforme mostrado na Figura 1.15.
Figura 1.13.
Figura 1.14.
Capítulo 1. Introdução 10
Figura 1.15 Fortran pronto para edição do programa-fonte.
Após a criação e inserção do programa-fonte dentro do projeto, o Fortran está pronto para ser
usado na edição do programa-fonte, conforme mostrado na Figura 1.15. Um exemplo de edição de
programa-fonte é apresentado a seguir.
1) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto mostrado
abaixo em vermelho (para aparecerem as aspas, deve-se clicar sobre a tecla delas e, em seguida, clicar
sobre a tecla de espaço em branco).
2) Para gravar ou salvar este texto, no menu do Fortran, executar: File, Save. Em seguida, na
extremidade inferior da janela principal do Fortran, surgirá uma mensagem informando o diretório e o
nome do programa-fonte que foi gravado ou salvo, como mostrado na Figura 1.16.
3) Comentários sobre este programa:
Capítulo 1. Introdução 11
a) Dentro do editor de textos do Fortran, os comandos da linguagem FORTRAN são mostrados na
cor azul, conforme pode ser visto na Figura 1.16. E o que é criado ou definido pelo programador é
mostrado na cor preta. Comandos são palavras-chave que têm uma função específica e devem ser
usados exatamente de acordo com suas normas.
b) Existem dezenas de comandos na linguagem FORTRAN. No caso do primeiro programa-fonte,
mostrado na Figura 1.16, são usados apenas dois comandos: WRITE e END.
c) Como será visto após a execução deste programa, ele simplesmente irá mostrar numa janela duas
linhas de texto: na primeira, Meu primeiro programa em Fortran; e, na segunda, Ano 2004. Isso é
conseguido com o comando WRITE. Qualquer texto colocado entre aspas após o comando
WRITE(*,*) é escrito numa janela.
d) O comando END é necessário para indicar o fim do programa.
Após concluir a edição de um programa-fonte, ele deve ser compilado. O processo de compilação
traduz o programa-fonte (que é um arquivo do tipo texto, isto é, que as pessoas conseguem ler
naturalmente, como o programa01.f90) no chamado programa-objeto, que é um arquivo do tipo binário
Capítulo 1. Introdução 12
(escrito na linguagem dos computadores, usando apenas os algarismos zero-0 e um-1). Uma linguagem de
programação de alto nível (Ramalho, 2000) como o FORTRAN se constitui numa forma “amigável” ou
relativamente fácil de se escrever programas. O aplicativo Fortran PowerStation 4.0, além do editor de
programas, também tem junto um compilador de programas. Para compilar um programa-fonte que está
aberto no editor de textos do Fortran, deve-se executar o seguinte no menu do Fortran: Build, Compile
Após a compilação, conforme é mostrado na Figura 1.17, aparecerão três linhas com mensagens
na subjanela da parte inferior do Fortran:
1) A primeira informa que o Fortran está compilando (Compiling) o programa-fonte.
2) A segunda informa o nome e o diretório do programa-fonte que está sendo compilado.
3) Finalmente, a terceira informa o nome do programa-objeto (no caso, programa01.obj) que foi gerado
e o número de erros (errors) e de avisos (warnings) relativos ao programa-fonte compilado. Se houver
algum erro, o programa-objeto não é gerado. Avisos não impedem a geração do programa-objeto. O
nome do programa-objeto é igual ao nome do programa-fonte mas com extensão obj
Capítulo 1. Introdução 13
seguinte no Windows: Start, Programs, Windows NT Explorer. Depois, deve-se acessar o diretório do
projeto, que deve estar dentro do diretório C:\Msdev\Projects
Capítulo 1. Introdução 14
1) A primeira informa que o Fortran está gerando o programa-executável, processo chamado de
lincagem (linking).
2) A segunda informa o nome do programa-executável (no caso, programa01.exe) que foi gerado e o
número de erros (errors) e de avisos (warnings) relacionados a ele. O nome do programa-executável é
igual ao nome do projeto mas com extensão exe
O programa-executável é gravado automaticamente dentro do subdiretório Debug, que fica dentro
do diretório do projeto, além de outros arquivos auxiliares. Isso pode ser visto com o aplicativo Windows
NT Explorer, como mostrado na Figura 1.19. Note nesta figura que no Windows NT Explorer a extensão
ou Type do programa-executável aparece como Application.
Capítulo 1. Introdução 15
2) No título desta janela, com fundo em azul, aparece o nome do programa que está sendo executado e o
diretório no qual ele se encontra, no caso C:\MSDEV\Projects\programa01\Debug\programa01.exe
3) Dentro desta janela, com fundo em preto, aparece o resultado da execução do programa. No caso, as
frases Meu primeiro programa em Fortran e Ano 2004. A ordem das duas frases é a mesma em que
elas foram colocadas no programa-fonte. Isso ocorre, porque o programa é executado do topo para
baixo, linha por linha do programa-fonte.
4) Além disso, também aparece a frase Press any key to continue. Como diz este aviso, basta clicar em
qualquer tecla para continuar. Ao fazer isso, a execução do programa é encerrada.
Capítulo 1. Introdução 16
1.13 EXERÍCIOS
Exercício 1.1
1) Editar um programa-fonte em FORTRAN para escrever a data atual.
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa
Exercício 1.2
1) Repetir o exercício 1.1 para escrever em linhas diferentes cada um dos seguintes itens: nome, e-mail,
endereço e telefone de uma pessoa.
Capítulo 1. Introdução 17
Capítulo 2. VARIÁVEIS DO TIPO INTEIRO
OBJETIVOS DO CAPÍTULO
• Conceitos de: variáveis do tipo inteiro, atribuição, avisos e erros de compilação, erros de execução,
comentários dentro do programa-fonte
• Operadores matemáticos básicos
• Comandos do FORTRAN: INTEGER e READ
INTEGER A
WRITE(*,*) "A"
WRITE(*,*) A
END
8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.2,
dentro da qual tem-se:
a) Na primeira linha, a letra A, resultado do comando WRITE(*,*) "A" do programa.
b) Na segunda linha, o valor zero, resultado do comando WRITE(*,*) A do programa. Isso ocorre
porque não foi definido um valor para a variável A, conforme o próprio Fortran informou durante
a compilação do programa. Portanto, sempre é necessário definir o valor de cada variável do
programa, caso contrário, por default, assume-se valor nulo.
c) E na terceira linha, a frase Press any key to continue. Como diz este aviso, basta clicar em
qualquer tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
9) Deve-se perceber a diferença que existe entre os comandos WRITE(*,*) "A" e WRITE(*,*) A do
programa. No primeiro, A é um comentário. No segundo, A é uma variável utilizada para armazenar
um valor inteiro na memória do computador.
INTEGER A
A = 3
WRITE(*,*) "A"
WRITE(*,*) A
END
2) Comentários sobre o programa: a única diferença entre a versão anterior (A) e a atual (B) do
programa02.f90 é a inclusão da segunda linha, ou seja, A = 3. O sinal de igualdade dentro de um
programa escrito em linguagem FORTRAN é utilizado para atribuir o valor que está do lado direito à
variável do lado esquerdo. Portanto, neste caso, o valor 3 é atribuído à variável A. Em outras palavras,
o valor 3 é armazenado num espaço da memória do computador que é identificado pelo nome ou
rótulo A, o nome da variável. Este valor utilizado (3) é apenas um exemplo; ele pode ser qualquer
número inteiro.
3) Nesta versão do programa, ao se executar Build, Compile, não haverá aviso (warning) porque, neste
caso, o valor da variável A está definido.
4) Gerar o programa-executável fazendo Build, Build.
5) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.3,
dentro da qual tem-se:
a) Na primeira linha, a letra A, resultado do comando WRITE(*,*) "A" do programa.
b) Na segunda linha, o valor 3, resultado do comando WRITE(*,*) A do programa e do comando
anterior, A = 3.
c) E na terceira linha, a frase Press any key to continue.
6) Deve-se perceber que o programa é executado, linha por linha, da primeira (INTEGER A) até a última
(END).
7) Um exemplo de erro de compilação é apresentado na Figura 2.4. Ele ocorre devido à eliminação do
segundo asterisco da terceira linha do programa. Erros de compilação ocorrem quando os comandos
INTEGER A
A = 3
WRITE(*,*) "Valor de A = ", A
2) Comentários sobre o programa: a diferença básica entre a versão anterior (B) e a atual (C) do
programa02.f90 é a junção dos dois comandos WRITE num só, na terceira linha do programa, isto é,
WRITE(*,*) "Valor de A = ", A. Esta forma do comando WRITE é usada quando se quer
escrever na mesma linha diversos elementos. No caso, são apenas dois elementos, ou seja, o
comentário Valor de A = e a variável A. Os elementos devem ser separados por vírgula.
3) Executar Build, Compile para compilar o programa.
4) Gerar o programa-executável fazendo Build, Build.
5) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.5,
dentro da qual tem-se:
a) Na primeira linha, como resultado do comando WRITE(*,*) "Valor de A = ", A do programa,
o comentário Valor de A = e, na mesma linha, o valor da variável A, cujo valor atribuído dentro
do programa foi 3.
b) E na segunda linha, a frase Press any key to continue.
INTEGER A
A = 4
A = 3
WRITE(*,*) "Valor de A = ", A
END
2) Comentários sobre o programa: a única diferença entre a versão anterior (C) e a atual (D) do
programa02.f90 é a inclusão da linha A = 4, que atribui o valor 4 à variável A.
3) Executar Build, Compile para compilar o programa.
4) Gerar o programa-executável fazendo Build, Build.
1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho, incluindo a linha em
branco.
! Programa02.f90
INTEGER A
2) Comentários sobre o programa: em cada linha do programa-fonte, tudo que estiver à direita do
símbolo ! (exclamação) não é executado pelo programa. São apenas comentários usados para
esclarecer o que faz cada parte do programa. Isso é chamado de documentação interna. Dentro do
editor do Fortran, todos os comentários ficam na cor verde, como é mostrado na Figura 2.6. Um
comentário pode envolver uma linha inteira do programa, como na primeira da versão E, ou apenas
uma parte, como na quarta linha do programa. Linhas em branco dentro do programa-fonte também
não são executadas. Elas equivalem a um comentário em branco. Um exemplo é a terceira linha do
programa02.f90, versão E, na Figura 2.6.
3) Executar Build, Compile para compilar o programa.
4) Gerar o programa-executável fazendo Build, Build.
5) Ao se executar o programa, através de Build, Execute, o resultado é o mesmo mostrado na Figura
2.5. Isso ocorre porque as diferenças entre a versão C e a atual (E) do programa02.f90 são apenas os
comentários e uma linha em branco, que não são executados pelo programa.
6) Para maior clareza e facilidade de compreensão do programa-fonte, recomenda-se que dentro dele
sejam usados comentários e linhas em branco.
INTEGER A, B, C, D, E, F, G
A = -6
B = 2
C = A + B
D = B - A
END
1) Dentro do Fortran, alterar o programa03.f90, versão A, para que fique exatamente igual ao texto
mostrado abaixo em vermelho, incluindo as linhas em branco.
INTEGER A, B, C, D, E, F, G
C = A + B
D = B - A
E = A * B
F = A / B
G = A ** B
END
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor −6 para a variável A e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*)
"Entre com o valor de B" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B,
resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é
necessário digitar o valor 2 para a variável B e, em seguida, clicar na tecla enter.
e) Em seguida, são apresentados os mesmos resultados da versão A do programa03.f90, conforme a
Figura 2.9.
6) Executar novamente o programa, entrando com outros valores para A e B. Em seguida, analisar
cada resultado, comparando-o com o valor esperado obtido de um cálculo mental.
7) Executar novamente o programa, com A = 6 e B = 0. Nenhum resultado é apresentado porque o
programa não consegue dividir 6 por 0. Isso gera um erro que interrompe a execução normal do
programa. Ao se implementar um programa, deve-se prepará-lo para que seja evitado qualquer
2.9 EXERÍCIOS
Exercício 2.1
Executar novamente o programa03.f90, versão B, com A = 2 e B = −1. Em seguida, analisar cada
resultado, comparando-o com o valor esperado obtido de um cálculo mental, especialmente o caso da
potenciação. No Fortran, para abrir um projeto já existente, como o programa03, basta executar File,
Open Workspace. Em seguida, indicar o diretório do projeto e selecionar o arquivo que tem o nome
do projeto e extensão mdp, no caso programa03.mdp
Exercício 2.2
Executar novamente o programa03.f90, versão B, usando números reais, isto é, A = 1.5 e B = 0.4.
Números reais são representados com o sinal de ponto para separar a parte inteira da decimal.
Exercício 2.3
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler três números inteiros
b) calcular a média aritmética deles
c) escrever os valores lidos e o valor da média aritmética juntamente com comentários para
identificá-los
2) Compilar o programa-fonte
Exercício 2.4
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler o primeiro valor (inteiro) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número inteiro) entre dois termos subseqüentes da P.A., denotada por D
c) ler o número (inteiro) de termos da P.A., denotado por N
d) calcular o último termo da P.A., denotado por AN
e) calcular a soma de todos os termos da P.A., denotado por SN
f) escrever os três valores lidos e os dois calculados juntamente com comentários para identificá-los
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa para A1 = 1, D = 3 e N = 5. Os resultados devem ser AN = 13 e SN = 35.
OBJETIVOS DO CAPÍTULO
• Conceitos de: variáveis do tipo real, tradução de expressões algébricas em FORTRAN, mistura de
variáveis do tipo inteiro com real, prioridade nas operações matemáticas
• Operadores matemáticos básicos
• Comando do FORTRAN: REAL
3.1 programa03c.f90
inteiro para a variável A, no caso 1. Mas o resultado do programa mostra o valor 1.000000
porque a variável A é do tipo real.
d) Na quarta linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer
tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
9) Executar novamente o programa, através de Build, Execute, com A = –0.0031. Junto a um número
real, a letra E é usada para representar números muito grandes ou muito pequenos através da chamada
notação científica ou exponencial. Desta forma, o valor –3.100000E-03 da variável A, mostrado na
Figura 3.3, significa –3.1x10-3, que é igual a –0.0031.
10) Executar novamente o programa, através de Build, Execute, com A = 1.0E+2. Pode-se fornecer
dados ao programa usando a notação científica ou exponencial, como no exemplo mostrado na Figura
3.4, onde A = 1.0E+2 = 1.0x102 = 100 = 1.0E2 = 1E2.
3.2 programa03d.f90
1) Nesta seção será usado um projeto já existente, no caso o projeto da seção anterior. Portanto, deve-se
executar o seguinte no Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa03 o programa-fonte programa03d.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 3.2.
D = A
B = 1 / D
C = 1.0 / D
END
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor 2.9 para a variável A, por exemplo, e, em seguida, clicar na tecla
enter.
c) Nas linhas seguintes, os resultados das variáveis D, B e C.
3.3 programa03e.f90
C = A + B
D = B - A
E = A * B
F = A / B
G = A ** B
END
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor 1.5 para a variável A, por exemplo, e, em seguida, clicar na tecla
enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*)
"Entre com o valor de B" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B,
resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é
necessário digitar o valor 0.4 para a variável B, por exemplo, e, em seguida, clicar na tecla
enter.
e) Nas linhas seguintes, os resultados das variáveis C, D, E, F e G.
7) Analisar cada resultado mostrado na Figura 3.6 comparando-o com o valor esperado obtido de um
cálculo mental ou com o uso de uma calculadora.
8) Executar novamente o programa com outros valores para A e B. Analisar cada novo resultado
comparando-o com o valor esperado obtido de um cálculo mental ou com o uso de uma calculadora.
H1 = A + B − C (3.1)
B
H2 = A + (3.2)
C
B
H4 = A + D (3.4)
C
B
H5 = A + (3.5)
CD
H6 = A + BC D (3.6)
H9 = (C 3 ) 2 (3.7)
1
H 10 = B3 (3.8)
3
3.5 programa03f.f90
1) Nesta seção será usado um projeto já existente, no caso o projeto da seção 3.3 deste capítulo.
Portanto, deve-se executar o seguinte no Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa03 o programa-fonte programa03f.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 3.6.
4) Comentários sobre o programa:
a) Nas duas primeiras linhas é usado o comando REAL para definir as variáveis do tipo real do
programa. Num mesmo programa, pode-se usar um ou mais comandos REAL ou INTEGER.
b) A linha READ(*,*) A, C, B, D do programa é usada para ler os valores de quatro variáveis. Um
único comando READ pode ser usado para a leitura de diversos valores que são atribuídos a
diversas variáveis, que têm que estar separadas por vírgula.
c) As expressões em FORTRAN para as variáveis H1 a H6, H9 e H10 correspondem
respectivamente às expressões algébricas dadas pelas Equações (3.1) a (3.8).
H1 = A + B - C
H2 = A + B / C
H3 = (A + B) / C
H4 = A + B / C * D
H5 = A + B / (C * D)
H6 = A + B * C ** D
H7 = A + (B * (C ** D))
H8 = 1.0 + 1.0E-10
H9 = C ** 3 ** 2
END
b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores da variáveis
A, C, B e D, resultado do comando READ(*,*) A, C, B, D do programa. Para que o programa
continue sua execução é necessário digitar quatro valores. Cada valor digitado será atribuído
respectivamente a uma das quatro variáveis, na mesma seqüência. Há várias formas de se entrar
com diversos valores para um único comando READ: digitando tudo na mesma linha, com cada
valor separado por vírgula ou espaço em branco; digitando cada valor e, em seguida, clicando na
tecla enter; ou misturas das três formas anteriores. A primeira forma foi usada no exemplo da
Figura 3.7 para se entrar com os valores 1, 2, 3 e 4, respectivamente, para as variáveis A, C, B e
D.
c) Nas linhas seguintes, os resultados das variáveis H1 a H12.
3.6 EXERCÍCIOS
Exercício 3.1
Escrever as expressões em linguagem FORTRAN que correspondem às seguintes expressões algébricas,
onde A, B e L são números reais e I e J são números inteiros:
B + 5
a) A =
100
1
b) A = + 3
B
10
1 1
c) L = I2 +
3− I J3
1
1 2 J 3
d) L = I + 3
1 I − 2
1+
I
Para verificar se a resposta de cada item está correta, basta implementar a expressão em FORTRAN num
programa e comparar seu resultado com o valor obtido com uma calculadora para a expressão algébrica
correspondente. Os dois resultados devem ser iguais. Isso também vale para o próximo exercício.
Exercício 3.2
Escrever as expressões algébricas que correspondem às seguintes expressões em linguagem FORTRAN:
a) A = ( ( B**(1.0/2) ) + 5) / 100
b) A = (1.0/10) + ( B**(1/3.0) )
Exercício 3.3
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler três números reais
b) calcular a média aritmética deles
c) escrever os valores lidos e o valor da média aritmética juntamente com comentários para
identificá-los
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa com os valores 1.0, 2.5 e −3.7. Em seguida, analisar o resultado da média
fornecido pelo programa comparando-o com o valor esperado obtido com uma calculadora.
5) Repetir o item 4 para os valores 10, −1E+3 e 2E-1.
Exercício 3.4
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler o primeiro valor (real) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número real) entre dois termos subseqüentes da P.A., denotada por D
c) ler o número (inteiro) de termos da P.A., denotado por N
d) calcular o valor (real) do último termo da P.A., denotado por AN
e) calcular a soma de todos os termos da P.A., denotado por SN
f) escrever os três valores lidos e os dois calculados juntamente com comentários para identificá-los
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa para A1 = 1.3, D = 3.9 e N = 5. Os resultados devem ser AN = 16.9 e SN = 45.5.
OBJETIVOS DO CAPÍTULO
• Conceitos de: variáveis do tipo caracter, strings, funções intrínsecas
• Funções intrínsecas do FORTRAN para variáveis do tipo caracter: ADJUSTL, ADJUSTR, TRIM e
LEN
• Comando do FORTRAN: CHARACTER
4.1 programa4a.f90
END
b) Na segunda linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer
tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
9) No FORTRAN, cada variável do tipo caracter deve ser declarada com a dimensão adequada à
quantidade máxima de letras, números, espaços em branco e símbolos que ela poderá conter. Quando
não se declara o tamanho, assume-se que seja apenas um caracter. Devido a isso, somente a letra U foi
apresentada como conteúdo da variável A, na versão 1 do programa4a.f90, embora ela tenha sido
definida com muito mais caracteres.
10) Para declarar a dimensão de uma variável do tipo caracter, basta colocar o tamanho entre parênteses
junto à palavra character, como exemplificado na versão 2 do programa4a.f90, na Tabela 4.2.
END
11) Alterar a primeira linha do programa4a.f90 para ficar igual à Tabela 4.2. Compilar novamente o
programa e gerar seu executável. Executar o programa. Agora, conforme a Figura 4.3, é apresentado
o conteúdo completo da variável A, já que ele ocupa apenas 18 caracteres e a variável A foi
dimensionada prevendo até 50 caracteres.
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa04 o programa-fonte programa4b.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 4.3.
4) Comentários sobre o programa:
a) A linha CHARACTER(50) A declara a variável A como sendo do tipo caracter. Este comando
reserva um espaço na memória do computador, utilizando o nome ou rótulo A, para armazenar até
50 caracteres alfanuméricos.
b) O comando READ do FORTRAN também pode ser usado para atribuir “valor” ou conteúdo a
uma variável do tipo caracter, desde que o conteúdo esteja entre aspas. Um exemplo é mostrado na
linha READ(*,*) A.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar, entre aspas, um conteúdo para a variável A, por exemplo, “Teste de hoje” e,
em seguida, clicar na tecla enter.
c) Na terceira linha, o conteúdo da variável A.
8) Executar novamente o programa, através de Build, Execute, testando outros conteúdos para a
variável A e vendo o resultado. Testar, por exemplo, uma frase com pelo menos duas palavras mas
sem usar aspas para definir o conteúdo de A.
4.3 programa4c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa04 o programa-fonte programa4c.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 4.4.
4) Comentários sobre o programa:
a) A linha CHARACTER(20) LOCAL, DIA declara duas variáveis, LOCAL e DIA, como sendo do tipo
caracter, cada uma podendo armazenar até 20 caracteres alfanuméricos.
b) A linha CHARACTER(10) HORA declara a variável HORA como sendo do tipo caracter, podendo
armazenar até 10 caracteres alfanuméricos.
c) A linha CHARACTER(90) FRASE declara a variável FRASE como sendo do tipo caracter, podendo
armazenar até 90 caracteres alfanuméricos.
d) A linha FRASE = "Frase: " // LOCAL // ", " // DIA // ", as " // HORA // " horas"
define o conteúdo da variável FRASE com base em alguns comentários que estão entre aspas e no
conteúdo das variáveis LOCAL, DIA e HORA. Isso é possível devido ao uso do operador de
concatenação cujo símbolo é composto por duas barras (//). Este operador permite juntar duas ou
mais variáveis do tipo caracter.
FRASE = "Frase: " // LOCAL // ", " // DIA // ", as " // HORA // " horas"
END
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável
LOCAL, resultado do comando READ(*,*) LOCAL do programa. Para que o programa continue
sua execução é necessário digitar o conteúdo da variável LOCAL, por exemplo, “Curitiba” e,
em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o dia =, resultado do comando WRITE(*,*) "Entre
com o dia =" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável
DIA, resultado do comando READ(*,*) DIA do programa. Para que o programa continue sua
execução é necessário digitar o conteúdo da variável DIA, por exemplo, “5 de abril de 2004” e,
em seguida, clicar na tecla enter.
e) Na quinta linha, o comentário Entre com a hora =, resultado do comando WRITE(*,*) "Entre
com a hora =" do programa.
f) Na sexta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável
HORA, resultado do comando READ(*,*) HORA do programa. Para que o programa continue sua
8) Deve-se notar na Figura 4.5 que a escrita do conteúdo da variável FRASE ocupou mais de uma linha.
Isso ocorre devido a sua extensão ser muito grande, isto é, superior ao número disponível de colunas
numa janela do tipo DOS.
9) No FORTRAN, se o conteúdo de uma variável é definido com menos caracteres do que o máximo
declarado, a diferença entre os caracteres ocupados e o máximo previsto é preenchida com espaços
em branco, como no conteúdo da variável FRASE. Por exemplo, a variável LOCAL foi declarada
com tamanho máximo de 20 caracteres. Mas seu conteúdo foi definido com “Curitiba”, palavra que
ocupa apenas 8 caracteres. Neste caso, os demais 12 caracteres são preenchidos com espaços em
branco. O mesmo problema ocorre com as demais variáveis. Formas de se resolver este problema são
abordadas na próxima seção.
10) Executar novamente o programa com outros conteúdos para as variáveis LOCAL, DIA e HORA.
4.4 programa4d.f90
1) Nesta seção será usado o mesmo projeto da seção anterior deste capítulo. Portanto, deve-se executar o
seguinte no Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa04 o programa-fonte programa4d.f90
L = LEN(A)
WRITE(*,*) "L de A = ", L
L = LEN(TRIM(ADJUSTL(A)))
WRITE(*,*) "L de A com TRIM e ADJUSTL = ", L
END
três strings que estão separadas por vírgula. A primeira é o comentário A =(;
f) A função ADJUSTL elimina os espaços em branco que estão à esquerda de uma string e os passa
à direita dela.
g) A função ADJUSTR elimina os espaços em branco que estão à direita de uma string e os passa à
esquerda dela.
h) A função TRIM elimina os espaços em branco que estão à direita de uma string.
i) O resultado das funções ADJUSTL, ADJUSTR e TRIM são strings.
j) A função LEN conta o número de caracteres de uma string ou variável do tipo caracter. Seu
resultado é um número inteiro.
k) Na instrução TRIM(ADJUSTL(A)) do programa, a função TRIM opera sobre o resultado da função
ADJUSTL sobre a variável A.
l) Na linha L = LEN(A) do programa, a função LEN opera sobre a variável A e atribui o resultado à
variável inteira L.
4.5 EXERCÍCIO
Exercício 4.1
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) declarar quatro variáveis do tipo caracter com dimensão de 5, 10, 20 e 30 caracteres
b) ler o conteúdo das quatro variáveis
c) escrever o conteúdo de cada uma das quatro variáveis
d) usando o operador de concatenação, escrever combinações das quatro variáveis lidas
e) aplicar e escrever o resultado da função ADJUSTL a cada uma das quatro variáveis lidas
f) aplicar e escrever o resultado da função ADJUSTR a cada uma das quatro variáveis lidas
g) aplicar e escrever o resultado da função TRIM a cada uma das quatro variáveis lidas
h) aplicar e escrever o resultado da função TRIM(ADJUSTL) a cada uma das quatro variáveis lidas
i) aplicar e escrever o resultado da função LEN a cada uma das quatro variáveis lidas
j) aplicar e escrever o resultado da função LEN(TRIM(ADJUSTL)) a cada uma das quatro variáveis
lidas
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa. Em seguida, comparar os resultados escritos com o esperado para cada caso.
OBJETIVOS DO CAPÍTULO
• Conceitos de: arquivo de saída, biblioteca, funções matemáticas intrínsecas
• Criar e usar arquivos para mostrar resultados da execução de um programa em FORTRAN
• Usar o aplicativo Notepad do Windows para mostrar o conteúdo de um arquivo durante a execução de
um programa em FORTRAN
• Funções matemáticas intrínsecas do FORTRAN
• Comandos do FORTRAN: WRITE(número,*), OPEN, CLOSE, USE, SYSTEM
5.1 programa5a.f90
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor 1 para a variável A, por exemplo, e, em seguida, clicar na tecla
enter.
c) Na terceira linha, o comentário Valor de A = e o valor da variável A, resultado do comando
WRITE(6,*) "Valor de A = ", A do programa. Deve-se notar que foi fornecido um valor
inteiro para a variável A, no caso 1. Mas o resultado do programa mostra o valor 1.000000
porque a variável A é do tipo real.
5.2 programa5b.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa05 o programa-fonte programa5b.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 5.2.
OPEN(7, file="saida5b.txt")
WRITE(7,*) "Valor de A = ", A
CLOSE(7)
END
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
e) O arquivo saida5b.txt é fechado, isto é, nada mais pode ser escrito nele após o comando CLOSE(7)
do programa.
8) A existência do arquivo saida5b.txt pode ser comprovada ao se executar Start, Programs, Windows
NT Explorer. Em seguida, indicar o diretório do projeto, no caso, programa05. Finalmente, ao se
clicar duas vezes sobre o nome do arquivo, ele será aberto, podendo-se ver o seu conteúdo.
9) Executar novamente o programa, através de Build, Execute, com A = −123. Neste caso, como já
existe o arquivo saida5b.txt ele será usado para escrever o novo resultado do programa sobre o
resultado anterior, conforme é mostrado na Figura 5.5. Ou seja, o resultado anterior, mostrado na
Figura 5.4 é eliminado ou apagado. Para evitar isso, é necessário gravar os resultados em arquivos
diferentes a cada execução do programa. Outra possibilidade é alterar o nome do arquivo de
resultados antes do programa ser executado novamente. Executar o indicado no item anterior (8)
para ver o novo conteúdo do arquivo saida5b.txt.
10) No comando OPEN também é possível especificar todo o caminho ou o diretório aonde o arquivo
deve ser criado ou aberto. Quando o diretório não é especificado, por default, usa-se o diretório do
projeto ou o diretório no qual o programa é executado. Por exemplo, trocar a linha OPEN(7,
file="saida5b.txt"), pelo seguinte: OPEN(7, file="C:\Temp\saida5b.txt"). Compilar
11) Na próxima seção, é apresentada uma forma de se automatizar a abertura do arquivo de saída. Isso
permite maior rapidez na visualização dos resultados de um programa.
5.3 programa5c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa05 o programa-fonte programa5c.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 5.3.
4) Comentários sobre o programa:
a) No programa5c.f90 são usados dois novos comandos do FORTRAN: USE e SYSTEM.
b) O comando USE biblio é usado para incluir dentro do programa uma “biblioteca” chamada biblio,
onde biblio deve ser substituído pelo nome da biblioteca desejada. Uma “biblioteca”, no presente
contexto, é uma coleção de comandos que não existem automaticamente dentro da linguagem
FORTRAN. Todos os comandos usados até aqui, por exemplo WRITE, já existem
automaticamente dentro da linguagem FORTRAN, mas o comando SYSTEM, não. Para ele ser
usado é necessário incluir no programa a biblioteca aonde este comando está definido, no caso é a
biblioteca chamada PORTLIB.
c) A linguagem FORTRAN permite a qualquer programador criar suas próprias bibliotecas, como
será visto nos capítulos avançados deste texto.
REAL A
INTEGER VER
END
d) No editor do aplicativo Fortran, o comando SYSTEM não fica na cor azul por não ser um dos
comandos básicos da linguagem FORTRAN. O comando SYSTEM é utilizado para executar
comandos que interagem com o sistema operacional Windows. Isso permite que, durante a
execução do programa escrito em FORTRAN, seja realizado o seguinte: executar outros
programas ou aplicativos; criar ou deletar diretórios ou arquivos; e qualquer outro comando
possível de se executar numa janela do tipo DOS. Para utilizar o comando SYSTEM deve-se
definir uma variável do tipo inteiro. Depois, usar esta variável na linha do programa aonde se
deseja executar o comando SYSTEM. Dentro de parênteses e aspas, deve-se incluir a seqüência
de comandos que se deseja executar no Windows.
e) A linha USE PORTLIB declara que a biblioteca chamada PORTLIB será acrescentada ao programa.
f) A linha VER = SYSTEM ("Notepad saida5c.txt") executa o comando SYSTEM para que o
aplicativo NOTEPAD do Windows abra o arquivo chamado saida5c.txt. A variável VER, usada
nesta linha, foi definida como uma variável do tipo inteiro na linha INTEGER VER do programa.
5) Executar Build, Compile para compilar o programa.
6) Gerar o programa-executável fazendo Build, Build.
7) Ao se executar o programa, através de Build, Execute, ocorrerá exatamente o mesmo já explicado na
seção anterior para o programa5b.f90. A única diferença é que quase no final da execução do
programa, o arquivo de resultados, que foi denominado de saida5c.txt, será aberto automaticamente
pelo aplicativo Notepad para mostrar o seu conteúdo. Ao se fechar o Notepad, a execução do
programa5c.f90 será encerrada.
8) No caso do comando OPEN ser usado para especificar todo o caminho ou o diretório aonde o arquivo
deve ser criado ou aberto, o comando SYSTEM também deve ser adaptado. Por exemplo, se o arquivo
5.4 programa5d.f90
1) Nesta seção será usado o mesmo projeto da seção anterior deste capítulo. Portanto, deve-se executar o
seguinte no Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no
projeto chamado programa05 o programa-fonte programa5d.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 5.4.
4) Comentários sobre o programa:
a) Conforme pode-se ver na Figura 5.6, ABS, LOG10, ACOS, COS e COSH estão escritos em azul
dentro do Fortran. Elas são chamadas de funções intrínsecas do FORTRAN, ou seja, são funções
ou comandos que existem dentro da linguagem FORTRAN. Elas são funções matemáticas usadas
em cálculos que envolvem variáveis do tipo real. Outras funções são apresentadas nas Tabelas
5.5 e 5.6.
b) A lista completa de funções matemáticas intrínsecas do FORTRAN pode ser vista no manual do
Fortran. Para acessá-lo, dentro da subjanela do lado esquerdo, deve-se executar: clicar uma vez
sobre o símbolo ?InfoView; e acessar as opções Reference, Procedures, Numeric Procedures e
as opções Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic
Procedures.
5) Executar Build, Compile para compilar o programa.
6) Gerar o programa-executável fazendo Build, Build.
7) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 5.7,
dentro da qual tem-se:
a) Na primeira linha, o comentário Entre com o valor de A =, resultado do comando WRITE(*,*)
"Entre com o valor de A =" do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor −10 para a variável A, por exemplo, e, em seguida, clicar na tecla
enter.
REAL A, B, C, Pi
INTEGER VER
OPEN(8, file="saida5d.txt")
B = ABS(A)
WRITE(8,*) "B = Módulo de A =", B
C = LOG10(B)
WRITE(8,*) "C: Logaritmo decimal de B =", C
Pi = ACOS(-1.0)
WRITE(8,*) "Pi =", Pi
D = COS(Pi)
WRITE(8,*) "Cosseno de Pi =", D
D = COSH(Pi)
WRITE(8,*) "Cosseno hiperbólico de Pi =", D
CLOSE(8)
END
8) Comparar cada resultado mostrado na Figura 5.8 com o resultado obtido de uma calculadora.
5.5 EXERCÍCIOS
Exercício 5.1
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler o primeiro valor (real) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número real) entre dois termos subseqüentes da P.A., denotada por D
c) ler o número (inteiro) de termos da P.A., denotado por N
d) calcular o valor (real) do último termo da P.A., denotado por AN
e) calcular a soma de todos os termos da P.A., denotado por SN
f) escrever no arquivo chamado saida_5p1.txt os três valores lidos e os dois calculados juntamente
com comentários para identificá-los
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa para A1 = 1.3, D = 3.9 e N = 5. Os resultados devem ser AN = 16.9 e SN = 45.5.
Exercício 5.2
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler algumas variáveis do tipo real
b) aplicar as funções matemáticas da Tabela 5.5 sobre as variáveis lidas
c) escrever no arquivo chamado saida_5p2.txt os valores lidos e os resultados calculados com as
funções juntamente com comentários para identificá-los
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa. Em seguida, comparar os resultados escritos com aqueles obtidos de uma
calculadora.
OBJETIVOS DO CAPÍTULO
• Conceitos e comandos de formatos de edição para variáveis do tipo inteiro, caracter e real
• Regras de edição de programas-fonte em FORTRAN
• Seqüência obrigatória dos comandos dentro de programas-fonte em FORTRAN
• Comandos do FORTRAN: WRITE(número,número) e FORMAT
CHARACTER(10) A, B
CHARACTER(20) C
INTEGER VER
C = A // B
OPEN(9, file="saida6a.txt")
WRITE(9,22) A
22 FORMAT ( A5, "= A no formato A5" )
WRITE(9,23) A
23 FORMAT ( A10, "= A no formato A10" )
WRITE(9,24) A
24 FORMAT("10X", 10X, "Conteúdo de A =", A10, 1/)
WRITE(9,25) A
25 FORMAT("T10", T10, "Conteúdo de A =", A10, 1/)
WRITE(9,10) A, B, C
10 FORMAT(5X, "A =", A10, 1/, 5X, "B =", A10, 1/, 5X, "C =", A20, 2/)
WRITE(9,11) A, B, C
11 FORMAT( 5X, "A =", A10, 1/, &
5X, "B =", A10, 1/, &
5X, "C =", A20, 2/ )
WRITE(9,12) A, B
12 FORMAT ( 2(A10), "= variáveis A e B no formato 2(A10)" )
CLOSE(9)
END
i) O identificador X é usado para deixar espaços em branco entre dois formatos de edição. Ele é
usado na forma NX, onde N é um número que representa a quantidade de espaços em branco. Um
exemplo é a linha 24 FORMAT("10X", 10X, "Conteúdo de A =", A10, 1/) do programa,
onde usou-se o formato 10X.
j) Nesta mesma linha do programa há o formato de edição N/, onde N é um número que representa a
quantidade de linhas que o cursor descerá quando encontrar este formato. Neste caso, uma linha,
devido ao formato 1/.
linha 10 FORMAT(5X, "A =", A10, 1/, 5X, "B =", A10, 1/, 5X, "C =", A20, 2/) do
programa. Portanto, a primeira variável (A) será escrita com o formato A10, que é o primeiro
formato de edição de variáveis que aparece no comando FORMAT. E as variáveis B e C serão
escritas com os formatos A10 e A20, respectivamente, que são o segundo e o terceiro formatos de
variáveis no comando FORMAT.
m) O comando FORMAT identificado pelo número 10 no programa tem exatamente a mesma função
que o comando FORMAT identificado pelo número 11. A única diferença é na edição do
programa-fonte. No 10 FORMAT, todos os formatos de edição usam apenas uma linha do
programa-fonte. Já no 11 FORMAT, são usadas três linhas. Neste caso, quando um mesmo
comando precisa ou se quer empregar mais de uma linha por motivos estéticos, usa-se o símbolo
&, ao final de cada linha do programa-fonte, para indicar que o comando continua na linha
seguinte. Isso vale para qualquer comando do FORTRAN.
n) O formato M(AN) é equivalente a M vezes o formato AN, onde N é o número de caracteres
reservados para se escrever uma variável do tipo caracter. Por exemplo, na linha 12 FORMAT (
2(A10), "= variáveis A e B no formato 2(A10)" ) do programa usa-se duas vezes o
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os conteúdos das
variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa6b.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 6.2.
INTEGER A, B, C
INTEGER VER
C = A + B
OPEN(9, file="saida6b.txt")
CLOSE(9)
END
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das
variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa
continue sua execução é necessário digitar 111 222, por exemplo, e, em seguida, clicar na tecla
enter.
d) Em seguida ocorrerá a criação do arquivo saida6b.txt, dentro do diretório do projeto, como
resultado do comando OPEN(9, file="saida6b.txt") do programa, uma vez que este arquivo
ainda não existe quando o programa6b.f90 for executado pela primeira vez. Este comando
também declara que será usado o número 9 no programa como referência ao arquivo saida6b.txt.
e) Como resultado da linha VER = SYSTEM("Notepad saida6b.txt") do programa, o aplicativo
Notepad abre automaticamente o arquivo saida6b.txt cujo conteúdo é mostrado na Figura 6.4. Na
segunda linha do arquivo saida6b.txt o valor da variável A (111) foi trocado por dois asteriscos.
Isso ocorre porque o formato usado (I2) é incompatível para se escrever o valor da variável A, que
neste caso precisa de pelo menos três colunas, ou seja, o formato mínimo seria I3. Para evitar este
tipo de problema, sempre se deve superdimensionar o espaço para escrever o valor de cada
variável.
8) Até entender, comparar o resultado de cada comando WRITE, e seu respectivo comando FORMAT
no programa6b.f90, mostrado em cada linha da Figura 6.4 ou no arquivo saida6b.txt.
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa6c.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 6.3.
4) Comentários sobre o programa:
a) O objetivo do programa6c.f90 é explicar alguns formatos de edição utilizados com variáveis do tipo
real.
b) No caso do programa6c.f90, os comandos FORMAT foram todos aglomerados no início do
programa-fonte, antes mesmo de seus respectivos comandos WRITE.
c) Os dois principais identificadores de variáveis do tipo real são representados pelas letras F e E.
REAL A, B, C
INTEGER VER
C = A + B
OPEN(9, file="saida6c.txt")
CLOSE(9)
END
usa-se três vezes o formato 1PE15.3 para se escrever três variáveis do tipo real.
5) Executar Build, Compile para compilar o programa.
6) Gerar o programa-executável fazendo Build, Build.
7) Ao se executar o programa, através de Build, Execute, surge uma janela do DOS, mostrada na
Figura 6.5, dentro da qual tem-se:
a) Na primeira linha, o comentário Variaveis do tipo real, resultado do comando WRITE(*,*)
"Variaveis do tipo real" do programa.
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das
variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa
continue sua execução é necessário digitar −1.234 2.22, por exemplo, e, em seguida, clicar na
tecla enter.
d) Em seguida ocorrerá a criação do arquivo saida6c.txt, dentro do diretório do projeto, como
resultado do comando OPEN(9, file="saida6c.txt") do programa, uma vez que este arquivo
ainda não existe quando o programa6c.f90 for executado pela primeira vez. Este comando também
declara que será usado o número 9 no programa como referência ao arquivo saida6c.txt.
e) Como resultado da linha VER = SYSTEM("Notepad saida6c.txt") do programa, o aplicativo
Notepad abre automaticamente o arquivo saida6c.txt cujo conteúdo é mostrado na Figura 6.6.
8) Até entender, comparar o resultado de cada comando WRITE, e seu respectivo comando FORMAT
no programa6c.f90, mostrado em cada linha da Figura 6.6 ou no arquivo saida6c.txt.
9) Executar novamente o programa com outros valores para as variáveis A e B. Analisar os novos
resultados.
10) Num mesmo comando FORMAT, podem ser usados identificados de variáveis do tipo inteiro,
caracter e real, além de comentários, e dos formatos NX, N/ e TN.
1) Em cada linha do programa, tudo que estiver após o símbolo de exclamação (!) não é executado pelo
programa. Serve apenas como comentário usado para esclarecer o que faz cada parte do programa.
Dentro do Fortran PowerStation 4.0, todos os comentários ficam na cor verde. Linhas em branco são
equivalentes a ter o símbolo (!) de comentário na primeira coluna de cada linha em branco.
2) Tudo que é criado ou definido pelo programador fica na cor preta dentro do Fortran PowerStation 4.0.
Até este capítulo foram vistos comandos da linguagem FORTRAN que podem ser divididos em
cinco tipos:
1) Comando para inclusão de biblioteca no programa-fonte: USE
2) Comandos para declarar tipos de variáveis: INTEGER, REAL e CHARACTER
3) Outros comandos intrínsecos (WRITE, READ, OPEN, CLOSE) ou não do FORTRAN (SYSTEM),
funções intrínsecas (LOG, TRIM etc) e qualquer outro comando criado pelo programador, por
exemplo, cálculos e operações com strings
4) Comando de encerramento do programa-fonte: END
5) Comando de edição: FORMAT
Se todos os cinco tipos de comandos forem usados simultaneamente num programa-fonte, a
seqüência obrigatória entre eles é exatamente a apresentada acima, exceto para o quinto tipo. O comando
FORMAT pode ficar em qualquer lugar do programa-fonte entre os comandos USE e END.
Para os comandos do tipo 2 (INTEGER, REAL e CHARACTER), a ordem entre eles pode ser
qualquer. O mesmo se aplica para os comandos do tipo 3, exceto com arquivos nos quais para um arquivo
específico a seqüência obrigatória é: OPEN, WRITE e outros comandos, CLOSE.
6.6 EXERCÍCIOS
Exercício 6.1
Editar um programa-fonte em FORTRAN para realizar um cálculo de interpolação linear executando o
seguinte algoritmo (passos):
1) Ler os valores de duas variáveis do tipo real, chamadas X1 e X2, que correspondem a dois dados
tabelados de uma variável independente
2) Ler os valores de duas variáveis do tipo real, chamadas Y1 e Y2, que correspondem a dois dados
tabelados de uma variável dependente de X
3) Ler o valor de uma variável do tipo real, chamada X, para o qual se deseja realizar a interpolação
4) Calcular o valor da variável Y, em função do valor de X, usando interpolação linear
5) Utilizando comandos FORMAT, escrever no arquivo chamado saida_6p1.txt os cinco valores lidos e
o resultado de Y, juntamente com comentários para identificá-los
6) Executar o programa para X1 = 10, X2 = 20, Y1 = 100, Y2 = −20 e X = 12. O resultado deve ser Y =
76.
Exercício 6.2
Editar um programa-fonte em FORTRAN para realizar cálculos com uma progressão geométrica (P.G.)
executando o seguinte algoritmo (passos):
1) Ler o primeiro valor (real) da P.G., denotado por a1
2) Ler a razão (número real) entre dois termos subseqüentes da P.G., denotada por q
3) Ler o número (inteiro) de termos da P.G., denotado por N
4) Calcular o valor (real) do último termo da P.G., denotado por an
5) Calcular a soma de todos os termos da P.G., denotado por Sn
6) Utilizando comandos FORMAT, escrever no arquivo chamado saida_6p2.txt os três valores lidos e os
dois calculados, juntamente com comentários para identificá-los
7) Executar o programa para a1 = 1.5, q = 1.1 e N = 20. Os resultados devem ser aproximadamente an ≈
9.174 e Sn ≈ 85.91.
OBJETIVOS DO CAPÍTULO
• Conceitos de: decisão, condição, operadores relacionais e lógicos, e opção
• Comandos do FORTRAN: IF – THEN – ELSE – END IF, SELECT CASE – CASE – END SELECT
7.1 programa7a.f90
valor de A for menor do que o valor de B, é executado o comando que está após o parênteses, no
caso, escrever um comentário. Aquilo que está dentro de parênteses é chamado de condição, que
pode ser simples ou composta. Para definir as condições, são usados os chamados operadores
relacionais (Tabela 7.3) e lógicos (Tabela 7.4).
c) Na linha IF ( (A < 0) .AND. (B < 0) ) WRITE(*,*) "A E B sao numeros NEGATIVOS" do
programa, tem-se um exemplo de condição composta. Cada condição simples é unida pelos
operadores lógicos .AND. e .OR., que em português significam E e OU.
d) Nas condições, além de variáveis, podem ser usados diretamente valores ou expressões
envolvendo valores e variáveis.
e) Nas demais linhas do programa, são testados todos os operadores relacionais e lógicos.
6) Executar Build, Compile para compilar o programa.
END
IF ( condições ) COMANDO
onde “condições” representa uma ou várias condições que devem ser satisfeitas para
que COMANDO seja executado.
8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 7.1,
dentro da qual tem-se:
a) Na primeira linha, o comentário Entre com os valores de A e B, resultado do comando
WRITE(*,*) "Entre com os valores de A e B" do programa.
9) Até entender, comparar os resultados da execução do programa7a.f90, mostrados na Figura 7.1, com
cada linha do programa-fonte onde exista um comando IF.
10) Executar novamente o programa com A = 1 e B = 1. Até entender, comparar os novos resultados,
mostrados na Figura 7.2, com cada linha do programa-fonte onde exista um comando IF.
11) Executar novamente o programa com A = 1 e B = −2. Até entender, comparar os novos resultados,
mostrados na Figura 7.3, com cada linha do programa-fonte onde exista um comando IF.
12) Executar novamente o programa com outros valores para A e B. Até entender, comparar os novos
resultados com cada linha do programa-fonte onde exista um comando IF.
7.2 programa7b.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa7b.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 7.5.
4) Comentários sobre o programa:
a) Este programa foi escrito para extrair as duas raízes de uma equação do 2o grau.
D = (B**2) - 4.0 * A * C
X1 = ( -B + SQRT(D) ) / ( 2.0 * A )
X2 = ( -B - SQRT(D) ) / ( 2.0 * A )
WRITE(*,*) "A primeira raiz real eh = ", X1
WRITE(*,*) "A segunda raiz real eh = ", X2
ELSE
X1 = -B / ( 2.0 * A )
X2 = SQRT(ABS(D)) / ( 2.0 * A )
WRITE(*,*) "A primeira raiz complexa eh = ", X1, " + ", X2, " i"
WRITE(*,*) "A segunda raiz complexa eh = ", X1, " - ", X2, " i"
END IF
END
c) Se não existir necessidade de comandos entre o ELSE e o END IF, pode-se usar a estrutura do
comando IF mostrada na Tabela 7.7.
d) Recomenda-se identar, isto é, deslocar para a direita os comandos entre o IF (SE) e o ELSE
(SENÃO), e entre o ELSE e o END IF, para que sejam facilmente visualizados os comandos que
são ou não executados. Um exemplo desta recomendação é mostrado no programa7b.f90, na
Tabela 7.5.
IF ( condições ) THEN
BLOCO 1 (uma ou várias linhas de programa com comandos)
ELSE
BLOCO 2 (uma ou várias linhas de programa com comandos)
END IF
onde “condições” representa uma ou várias condições que devem ser satisfeitas para
que o bloco 1 seja executado;
se as “condições” não forem satisfeitas, o bloco 2 é executado.
IF ( condições ) THEN
BLOCO (uma ou várias linhas de programa com comandos)
END IF
onde “condições” representa uma ou várias condições que devem ser satisfeitas para
que o bloco de linhas de programa seja executado.
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das
variáveis A, B e C, resultado do comando READ(*,*) A, B, C do programa. Para que o
programa continue sua execução é necessário digitar 1 −5 6, por exemplo, e, em seguida, clicar
na tecla enter.
8) Até entender, comparar os resultados da execução do programa7b.f90, mostrados na Figura 7.4, com
cada linha do programa-fonte.
9) Executar novamente o programa com A = 1, B = −6 e C = 10. Até entender, comparar os novos
resultados, mostrados na Figura 7.5, com cada linha do programa-fonte.
10) Executar novamente o programa com outros valores para A, B e C. Até entender, comparar os
novos resultados com cada linha do programa-fonte.
7.3 programa7c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa7c.f90
SELECT CASE ( A )
CASE ( -1000:1 )
WRITE(*,*) "Valor de A estah entre -1000 e 1"
CASE ( 2, 4 )
WRITE(*,*) "Valor de A eh 2 ou 4"
CASE ( 3 )
WRITE(*,*) "Valor de A eh 3"
CASE ( 5:2000 )
WRITE(*,*) "Valor de A estah entre 5 e 2000"
CASE DEFAULT
WRITE(*,*) "Valor de A eh menor do que -1000 ou maior do que 2000"
END SELECT
END
CASE ( valor1 )
BLOCO 1
CASE ( valor2 )
BLOCO 2
CASE DEFAULT
BLOCO DEFAULT
END SELECT
onde “valor” representa um valor inteiro, alguns valores separados por vírgula ou,
ainda, um intervalo de valores separados por dois pontos;
apenas o bloco de comandos correspondente ao “valor” da variável é executado.
A variável de seleção pode ser do tipo inteiro ou caracter. No caso de variável
caracter, os “valores” devem ser strings entre aspas.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar o valor −10 para a variável A, por exemplo, e, em seguida, clicar na tecla
enter.
7.4 EXERCÍCIOS
Exercício 7.1
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores inteiros de três variáveis, denotadas por A, B e C
2) Determinar qual das variáveis tem o menor e o maior valor
Exercício 7.2
Alterar o programa7b.f90 para que não ocorra erro de execução quando o usuário entrar com valor nulo
para a variável A, e que seja calculado e escrito o valor da única raiz deste caso.
Exercício 7.3
Editar um programa-fonte em FORTRAN para calcular as raízes de uma equação algébrica cúbica.
Exercício 7.4
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
OBJETIVOS DO CAPÍTULO
• Conceito de ciclo
• Comandos do FORTRAN: DO – END DO, EXIT
8.1 programa8a.f90
A = 20
WRITE(*,*) "Valor de A antes do ciclo =", A
DO A = 1, 10, 1
WRITE(*,*) "Valor de A dentro do ciclo =", A
END DO
END
5) Neste programa são usados dois novos comandos do FORTRAN: DO e END DO, que definem um
ciclo. Ele são usados para executar várias vezes uma ou mais linhas do programa. Explicações gerais
sobre o seu funcionamento são apresentadas na próxima seção.
6) Executar Build, Compile para compilar o programa.
Capítulo 8. Ciclos 93
7) Gerar o programa-executável fazendo Build, Build.
8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 8.1,
dentro da qual tem-se:
a) Na primeira linha, o valor corrente ou atual da variável A na memória do computador, resultado
do comando WRITE(*,*) "Valor de A antes do ciclo =", A do programa. O valor escrito,
20, é resultado da linha anterior do programa, A = 20.
b) Da segunda à décima-primeira linha, o programa executa 10 vezes a linha WRITE(*,*) "Valor
de A dentro do ciclo =", A porque ela está dentro de um ciclo definido pelos comandos DO
e END DO. Deve-se notar que o valor da variável A muda a cada repetição do ciclo.
c) Na décima-segunda linha, o programa escreve o valor da variável A como resultado da linha
WRITE(*,*) "Valor de A depois do ciclo =", A , que já está fora do ciclo.
8.2 programa8b.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa8b.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 8.2.
Capítulo 8. Ciclos 94
Tabela 8.2 Programa8b.f90.
INTEGER A, INICIO, FIM, PASSO, B, C
C = MAX ( B, 0 )
END
Capítulo 8. Ciclos 95
b.4) No caso de não se entrar no ciclo, a execução do programa passa diretamente à linha
que estiver abaixo do comando END DO
onde os valores das variáveis INICIO, FIM e PASSO devem ter sido definidos antes da
execução do programa chegar ao comando DO.
c) O número de execuções (variável C) do ciclo depende das variáveis do tipo inteiro INICIO, FIM e
PASSO, calculado através de
C = MAX ( B, 0 ) (8.2)
onde o resultado da função MAX(B,0) é o maior valor entre a variável B e o valor zero. O
resultado de C pode ser 0, 1, 2, 3 etc. Portanto, o ciclo pode ser executado uma vez, diversas vezes
ou nenhuma vez.
d) O valor da variável PASSO pode ser positivo ou negativo; nulo, não. Portanto, pode-se ter um
ciclo cujo valor de A é progressivo (PASSO > 0) ou regressivo (PASSO < 0). Se PASSO = 1, seu
valor não precisa ser declarado no comando DO.
e) O valor da variável A não pode ser alterado nas linhas que estão entre os comando DO e END
DO. Se isso for feito, resultará num erro de compilação.
f) Recomenda-se identar, isto é, deslocar para a direita todas as linhas do programa que estão entre
os comandos DO e END DO para que facilmente se perceba os comandos que compõem o ciclo.
Exemplos desta recomendação são mostrados no programa8a.f90 (Tabela 8.1) e no
programa8b.f90 (Tabela 8.2).
5) Executar Build, Compile para compilar o programa.
6) Gerar o programa-executável fazendo Build, Build.
Capítulo 8. Ciclos 96
7) Ao se executar o programa, através de Build, Execute, surge uma janela do DOS, mostrada na
Figura 8.2, dentro da qual tem-se:
a) Na primeira linha, o comentário Entre com os valores inteiros de A, INICIO, FIM e PASSO,
resultado do comando WRITE(*,*) "Entre com os valores inteiros de A, INICIO, FIM
e PASSO" do programa.
b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores das
variáveis A, INICIO, FIM e PASSO, resultado do comando READ(*,*) A, INICIO, FIM,
PASSO do programa. Para que o programa continue sua execução é necessário digitar 20 1 10 1,
8) Até entender, analisar os resultados do programa8b.f90, mostrados na Figura 8.2, considerando cada
linha do programa-fonte e as explicações descritas no item 4 acima. Deve-se notar que o ciclo do
programa8b.f90 é idêntico ao do programa8a.f90, Figura 8.1, devido aos valores usados para as
variáveis INICIO, FIM e PASSO. Neste caso tem-se um ciclo progressivo, pois PASSO > 0.
9) Executar novamente o programa com A = 20, INICIO = −5, FIM = 5 e PASSO = 1. Neste caso
tem-se um ciclo progressivo, pois PASSO > 0. Até entender, analisar os novos resultados, mostrados
na Figura 8.3, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
10) Executar novamente o programa com A = 20, INICIO = 20, FIM = 11 e PASSO = −1. Neste caso
tem-se um ciclo regressivo, pois PASSO < 0. Até entender, analisar os novos resultados, mostrados
na Figura 8.4, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
Capítulo 8. Ciclos 97
Figura 8.3 Resultado do programa8b.f90 para A = 20, INICIO = −5, FIM = 5 e PASSO = 1.
Figura 8.4 Resultado do programa8b.f90 para A = 20, INICIO = 20, FIM = 11 e PASSO = −1.
11) Executar novamente o programa com A = 20, INICIO = 12, FIM = 15 e PASSO = 2. Neste caso
tem-se um ciclo progressivo, pois PASSO > 0. Até entender, analisar os novos resultados, mostrados
na Figura 8.5, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
12) Executar novamente o programa com A = 20, INICIO = 11, FIM = 20 e PASSO = −1. Neste caso
tem-se um ciclo regressivo, pois PASSO < 0. Até entender, analisar os novos resultados, mostrados
na Figura 8.6, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
8.3 programa8c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
Capítulo 8. Ciclos 98
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
Figura 8.5 Resultado do programa8b.f90 para A = 20, INICIO = 12, FIM = 15 e PASSO = 2.
Figura 8.6 Resultado do programa8b.f90 para A = 20, INICIO = 11, FIM = 20 e PASSO = −1.
Capítulo 8. Ciclos 99
d) Quando a condição estipulada na linha IF ( SOMA > FIM ) EXIT do programa for satisfeita, o
comando EXIT será executado. Em seguida, a execução do programa é transferida para a linha
WRITE(*,*) "Valor de A depois do ciclo =", A do programa, que é a linha seguinte ao
SOMA = 0
CUBO = 0
END
b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores das
variáveis INICIO, FIM e PASSO, resultado do comando READ(*,*) INICIO, FIM, PASSO do
programa. Para que o programa continue sua execução é necessário digitar 1 10 1, por exemplo,
e, em seguida, clicar na tecla enter.
c) Em seguida são apresentados os resultados correspondentes à execução do programa.
8.4 EXERCÍCIOS
Exercício 8.1
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler o valor inteiro de uma variável, denotada por N
2) Determinar se N é um número primo
3) Mostrar o resultado, isto é, se N é um número primo ou não.
Exercício 8.2
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
Exercício 8.3
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de
uma progressão aritmética, cujo problema está definido no exercício 5.1
Exercício 8.4
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de
uma progressão geométrica, cujo problema está definido no exercício 6.2
OBJETIVOS DO CAPÍTULO
• Conceitos de: conjunto, elemento, alocação dinâmica de memória
• Comandos do FORTRAN: DIMENSION, ALLOCATABLE, ALLOCATE, MINVAL, MAXVAL,
SUM
9.1 programa9a.f90
DO NOTA = 1, QUANTIDADE_NOTAS
READ(*,*) NOTAS(NOTA)
END DO
MINIMO = NOTAS(1)
MAXIMO = NOTAS(1)
SOMA = NOTAS(1)
DO NOTA = 2, QUANTIDADE_NOTAS
IF ( NOTAS(NOTA) < MINIMO ) MINIMO = NOTAS(NOTA)
IF ( NOTAS(NOTA) > MAXIMO ) MAXIMO = NOTAS(NOTA)
SOMA = SOMA + NOTAS(NOTA)
END DO
END
e) O comando ALLOCATABLE é usado para definir uma variável do tipo alocável, isto é, uma
variável do tipo conjunto cuja quantidade de elementos que a compõe é definida posteriormente
dentro do programa em função de alguma outra variável.
f) O comando ALLOCATE é usado para definir quantos elementos compõem uma variável do tipo
conjunto e reservar o espaço de memória correspondente no computador. Não se pode atribuir
i) Cada elemento de uma variável do tipo conjunto é referenciado por um número inteiro, chamado
índice, que corresponde à ordem dele dentro do conjunto. Este índice deve ficar entre parênteses
após o nome da variável do tipo conjunto. O índice ou o número do elemento pode ser
representado por uma variável, por exemplo, na linha READ(*,*) NOTAS(NOTA) do programa, que
está dentro de um ciclo. Neste ciclo, a variável NOTA corresponde a cada elemento da variável
NOTAS.
j) Na linha MINIMO = NOTAS(1) do programa, está sendo inicializado o valor da variável MINIMO
atribuindo a ela o valor do primeiro elemento da variável NOTAS. O mesmo ocorre nas duas
linhas seguintes com as variáveis MAXIMO e SOMA.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável
QUANTIDADE_NOTAS, resultado do comando READ(*,*) QUANTIDADE_NOTAS do programa.
Para que o programa continue sua execução é necessário digitar 5, por exemplo, e, em seguida,
clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com as notas, resultado do comando WRITE(*,*) "Entre
com as notas" do programa.
d) Na quarta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os
elementos da variável NOTAS, resultado do comando READ(*,*) NOTAS(NOTA) do programa,
que está dentro de um ciclo que começa no primeiro elemento e vai até o último do conjunto.
Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada
vez; assim é necessário digitar cada nota e, em seguida, clicar na tecla Enter antes de se digitar
uma nova nota. Usar, por exemplo, os valores 7, 8.5, 5.7, 4.9 e 9.
e) Em seguida são apresentados os resultados correspondentes à execução do programa.
11) Até entender, analisar os resultados do programa9a.f90, mostrados na Figura 9.1, considerando cada
linha do programa-fonte, as explicações descritas no item 6 acima e a média obtida com o uso de uma
calculadora.
12) Executar novamente o programa com outros valores. Até entender, analisar os novos resultados do
programa9a.f90 considerando cada linha do programa-fonte, as explicações descritas no item 6 acima
e a média obtida com o uso de uma calculadora.
9.2 programa9b.f90
1) Nesta seção será usado o programa9a.f90, da seção anterior, como base para um novo programa.
Portanto, deve-se executar o seguinte no Fortran:
a) Selecionar todas as linhas do programa9a.f90 com o botão esquerdo do mouse
b) Edit, Copy para salvar este programa-fonte na memória do computador
2) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa9a.f90
b) Edit, Cut para retirar o programa9a.f90 do projeto.
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa9b.f90
4) No Fortran, executar Edit, Paste para inserir o programa9a.f90 dentro do programa9b.f90.
5) Dentro do espaço de edição do Fortran, na subjanela maior, alterar o programa9a.f90 para que fique
exatamente igual ao texto em vermelho mostrado na Tabela 9.3.
6) Objetivos do programa:
a) Utilizar três novas funções matemáticas intrínsecas do FORTRAN: MINVAL, MAXVAL e SUM,
que são utilizadas com variáveis do tipo conjunto
b) Determinar os valores mínimo e máximo e a média de um conjunto de variáveis do tipo real
7) Comentários sobre o programa:
a) Neste programa emprega-se exatamente o mesmo algoritmo do programa anterior, isto é, os dois
programas fazem exatamente o mesmo. A diferença é que neste programa os valores mínimo e
máximo e a média de um conjunto de variáveis do tipo real são obtidos através de três novas
funções matemáticas intrínsecas do FORTRAN: MINVAL, MAXVAL e SUM, que são utilizadas
DO NOTA = 1, QUANTIDADE_NOTAS
READ(*,*) NOTAS(NOTA)
END DO
MINIMO = MINVAL(NOTAS)
MAXIMO = MAXVAL(NOTAS)
SOMA = SUM(NOTAS)
END
9.3 programa9c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa9b.f90
b) Edit, Cut para retirar o programa9b.f90 do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa9c.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 9.4.
4) Objetivos do programa:
a) Mostrar como realizar operações com todos os elementos de um conjunto num único comando
b) Mostrar o uso de funções matemáticas intrínsecas do FORTRAN com variáveis do tipo conjunto
c) Mostrar duas formas de escrever o conteúdo de variáveis do tipo conjunto
5) Comentários sobre o programa:
a) Na linha REAL, ALLOCATABLE, DIMENSION(:) :: CONJUNTO_A, CONJUNTO_B, CONJUNTO_C do
programa, estão sendo definidas três variáveis (CONJUNTO_A, CONJUNTO_B e
CONJUNTO_C) com as seguintes características: do tipo conjunto, devido ao comando
DIMENSION(:); do tipo alocável, devido ao comando ALLOCATABLE; e do tipo real, ou seja,
cada elemento das três variáveis poderá conter números reais, devido ao comando REAL.
b) Na linha CONJUNTO_B = CONJUNTO_A + 10 do programa, soma-se o valor 10 ao valor de cada
elemento da variável CONJUNTO_A e atribui-se o resultado a cada elemento da variável
CONJUNTO_B. Portanto, num único comando estão sendo feitos cálculos com todos os
elementos de um conjunto. Para que isso seja possível, as duas variáveis do tipo conjunto têm que
ter exatamente o mesmo número de elementos. Esta linha do programa poderia ser substituída de
forma equivalente ao seguinte:
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS
CONJUNTO_B(ELEMENTO) = CONJUNTO_A(ELEMENTO) + 10
END DO
c) Na linha CONJUNTO_C = EXP(CONJUNTO_A) do programa, calcula-se a exponencial do valor de
cada elemento da variável CONJUNTO_A e atribui-se o resultado a cada elemento da variável
CONJUNTO_C. Assim, num único comando estão sendo feitos cálculos com todos os elementos
de um conjunto envolvendo uma função matemática intrínseca do FORTRAN, no caso a função
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS
READ(*,*) CONJUNTO_A(ELEMENTO)
END DO
CONJUNTO_B = CONJUNTO_A + 10
CONJUNTO_C = EXP(CONJUNTO_A)
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS
WRITE(*,20) ELEMENTO, CONJUNTO_C(ELEMENTO)
20 FORMAT(10X, "CONJUNTO_C(", I2, ") = ", 1PE15.3 )
END DO
END
d) Há duas formas de escrever os valores dos elementos de uma variável do tipo conjunto. A
primeira é agir da mesma forma que no caso de uma variável simples. Por exemplo, como
resultado da linha WRITE(*,*) "CONJUNTO_B = ", CONJUNTO_B do programa, serão escritos os
valores de todos os elementos da variável CONJUNTO_B, na seqüência do primeiro ao último
CONJUNTO_A" do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável
QUANTIDADE_ELEMENTOS, resultado do comando READ(*,*) QUANTIDADE_ELEMENTOS do
programa. Para que o programa continue sua execução é necessário digitar 6, por exemplo, e, em
seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com os valores do CONJUNTO_A, resultado do comando
WRITE(*,*) "Entre com os valores do CONJUNTO_A" do programa.
d) Na quarta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os
elementos da variável CONJUNTO_A, resultado do comando READ(*,*)
elemento e vai até o último do conjunto. Deve-se perceber que o comando READ é usado para ler
o valor de apenas um elemento a cada vez; assim é necessário digitar cada valor e, em seguida,
clicar na tecla Enter antes de se digitar um novo valor. Usar, por exemplo, os valores 1, 2, 3, 4, 5
e 6.
e) Em seguida são apresentados os resultados correspondentes à execução do programa.
10) Até entender, analisar os resultados do programa9c.f90, mostrados na Figura 9.2, considerando cada
linha do programa-fonte e as explicações descritas no item 5 acima.
11) Executar novamente o programa com outros dados. Até entender, analisar os novos resultados
considerando cada linha do programa-fonte e as explicações descritas no item 5 acima.
9.4 programa9d.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa9c.f90
b) Edit, Cut para retirar o programa9c.f90 do projeto.
2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa9d.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 9.5.
4) Objetivo do programa: aplicar os conceitos já vistos nas seções anteriores deste capítulo ao caso de
uma progressão aritmética (P.A.) onde os valores dos elementos da variável do tipo conjunto são
inteiros.
5) Algoritmo do programa:
a) Definir os tipos de todas as variáveis
b) Ler o número de termos da progressão aritmética (P.A.)
c) Alocar a memória para a variável do tipo conjunto chamada A
ALLOCATE ( A(N) )
DO TERMO = 2, N
A(TERMO) = A(1) + (TERMO - 1) * D
END DO
SN = N * ( A(1) + A(N) ) / 2
DO TERMO = 1, N
WRITE(*,10) TERMO, A(TERMO)
10 FORMAT(3X, "A(", I3, ") = ", I8 )
END DO
END
9.5 EXERCÍCIOS
Exercício 9.1
Adaptar o programa9d.f90 para escrever os valores dos termos da progressão aritmética num arquivo,
bem como a soma dos valores de todos os termos
Exercício 9.2
Adaptar o programa9d.f90 para calcular e escrever os valores dos termos de uma progressão geométrica
num arquivo, bem como a soma dos valores de todos os termos
Exercício 9.3
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Definir os tipos de todas as variáveis, sendo uma delas do tipo conjunto para caracteres, chamada
NOMES
Exercício 9.4
Adaptar o programa9b.f90 para:
1) Escrever num arquivo os valores das notas e os resultados calculados
2) Calcular e escrever o desvio-padrão (D) das notas, definido por
∑(N m − Ni )2
D = i =1
Exercício 9.5
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores inteiros de cinco variáveis
2) Ordenar e escrever as cinco variáveis em ordem crescente de valor
3) Ordenar e escrever as cinco variáveis em ordem decrescente de valor
Exercício 9.6
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores inteiros de cinco variáveis
2) Determinar e escrever quais variáveis têm valor par
3) Determinar e escrever quais variáveis têm valor ímpar
4) Calcular a soma dos valores pares
5) Calcular a soma dos valores ímpares
OBJETIVOS DO CAPÍTULO
• Conceitos de: conjunto multidimensional (matriz), ciclo implícito, ciclo duplo
• Comandos do FORTRAN: DIMENSION(:,:), MATMUL
10.1 programa10a.f90
DO LINHA = 1, LINHAS
WRITE(*,*) "Entre com os valores dos elementos da matriz da linha =", LINHA
DO COLUNA = 1, COLUNAS
READ(*,*) MATRIZ(LINHA,COLUNA)
END DO
END DO
END
Tabela 10.2 Sintaxe de comandos para variáveis do tipo matriz (conjunto bidimensional).
i) Cada elemento de uma variável do tipo conjunto bidimensional é referenciado por dois números
inteiros, chamado índices, que correspondem à ordem dele dentro do conjunto. O primeiro índice
corresponde à linha que o elemento ocupa dentro da matriz e o segundo, à coluna. Estes índices
devem ficar dentro de parênteses, e separados por vírgula, após o nome da variável do tipo
conjunto bidimensional. Os índices ou os números do elemento podem ser representados por
variáveis, por exemplo, na linha READ(*,*) MATRIZ(LINHA,COLUNA) do programa, que está
dentro de um ciclo duplo.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável
COLUNAS, resultado do comando READ(*,*) COLUNAS do programa. Para que o programa
continue sua execução é necessário digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, o comentário Entre com os valores dos elementos da matriz da linha = 1,
resultado do comando WRITE(*,*) "Entre com os valores dos elementos da matriz da
linha =", LINHA do programa.
f) Na sexta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os
elementos da primeira linha da matriz, resultado dos comandos
DO COLUNA = 1, COLUNAS
READ(*,*) MATRIZ(LINHA,COLUNA)
END DO
do programa, que contêm um ciclo que começa no elemento da primeira coluna e vai até a última.
Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada
vez; assim é necessário digitar cada valor e, em seguida, clicar na tecla Enter antes de se digitar
10.2 programa10b.f90
1) Nesta seção será usado o programa10a.f90, da seção anterior, como base para um novo programa.
Portanto, deve-se executar o seguinte no Fortran:
a) Selecionar todas as linhas do programa10a.f90 com o botão esquerdo do mouse
b) Edit, Copy para salvar este programa-fonte na memória do computador
2) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa10a.f90
b) Edit, Cut para retirar o programa10a.f90 do projeto.
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa10b.f90
4) No Fortran, executar Edit, Paste para inserir o programa10a.f90 dentro do programa10b.f90.
5) Dentro do espaço de edição do Fortran, na subjanela maior, alterar o programa10a.f90 para que
fique exatamente igual ao texto em vermelho mostrado na Tabela 10.3.
6) Objetivos do programa:
a) Aplicar os comandos DIMENSION, ALLOCATABLE e ALLOCATE a conjuntos bidimensionais
(matrizes) do tipo real
b) Ler valores de elementos de matrizes e escrevê-los num arquivo utilizando ciclos simples e
implícitos
c) Realizar operações matemáticas com matrizes
7) Comentários sobre o programa:
consegue-se ler os valores de todos os elementos de cada linha da MATRIZ_A. Isso é possível
porque: existe um ciclo externo, definido pela linha DO LINHA = 1, LINHAS do programa, que a
cada execução percorre uma linha da matriz; e também existe um ciclo chamado de implícito na
linha READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS ) do programa, que a
cada execução percorre todas as colunas da matriz.
b) O chamado ciclo implícito ou aninhado é utilizado sem os comandos DO e END DO, conforme
exemplificado na leitura e escrita da MATRIZ_A e na escrita da MATRIZ_B e da MATRIZ_C no
programa10b.f90.
DO LINHA = 1, LINHAS
WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A da linha =", LINHA
READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
DO LINHA = 1, LINHAS
DO COLUNA = 1, COLUNAS
MATRIZ_B(LINHA,COLUNA) = CONSTANTE * MATRIZ_A(LINHA,COLUNA)
DO LINHA = 1, LINHAS
DO COLUNA = 1, COLUNAS
MATRIZ_C(LINHA,COLUNA) = MATRIZ_A(LINHA,COLUNA) + MATRIZ_B(LINHA,COLUNA)
END DO
END DO
OPEN(10, FILE="SAIDA10B.TXT")
WRITE(10,31) CONSTANTE
31 FORMAT("CONSTANTE = ", I5, /)
WRITE(10,32)
32 FORMAT(3X, "*** MATRIZ_A (dados) ***")
DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
33 FORMAT( 10 (3X, 1PE10.3 ) )
END DO
WRITE(10,41)
41 FORMAT(1/, 3X, "*** MATRIZ_B (CONSTANTE * MATRIZ_A) ***")
DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_B(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
WRITE(10,51)
51 FORMAT(1/, 3X, "*** MATRIZ_C (MATRIZ_A + MATRIZ_B) ***")
DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_C(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
CLOSE(10)
END
E as cinco linhas de programa mostradas no item d acima podem ser substituídas de forma
equivalente a apenas
MATRIZ_C = MATRIZ_A + MATRIZ_B
g) Com conjuntos multidimensionais, também se pode utilizar as funções intrínsecas das Tabelas 5.5
e 5.6, conforme já visto no programa9c.f90 do capítulo 9 para conjuntos unidimensionais.
8) Algoritmo do programa:
a) Definir os tipos de todas as variáveis
b) Ler o valor do tipo inteiro de uma constante e a quantidade de elementos em cada linha e coluna
das variáveis MATRIZ_A, MATRIZ_B e MATRIZ_C, que são do tipo conjunto bidimensional
c) Alocar memória para as três variáveis do tipo matriz
d) Ler os valores de todos os elementos da variável MATRIZ_A no formato de matriz
c) Na terceira linha, o comentário Entre com o numero de linhas das matrizes (inteiro), resultado do
comando WRITE(*,*) "Entre com o numero de linhas das matrizes (inteiro)" do
programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável
LINHAS, resultado do comando READ(*,*) LINHAS do programa. Para que o programa continue
sua execução é necessário digitar 3, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, o comentário Entre com o numero de colunas das matrizes (inteiro), resultado do
comando WRITE(*,*) "Entre com o numero de colunas das matrizes (inteiro)" do
programa.
h) Na oitava linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os
elementos da primeira linha da matriz; digitar 1 4, por exemplo, e, em seguida, clicar na tecla
Enter. Para a segunda linha da matriz, digitar 2 5, por exemplo, e, em seguida, clicar na tecla
Enter. Para a terceira linha da matriz, digitar 3 6, por exemplo, e, em seguida, clicar na tecla
Enter. Estes dados, nesta seqüência, correspondem à seguinte matriz:
1 4
2 5 (10.3)
3 6
12) Até entender, analisar os resultados do programa10b.f90, mostrados na Figura 10.3, considerando
cada linha do programa-fonte e as explicações descritas no item 7 acima.
10.3 EXERCÍCIOS
Exercício 10.1
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler o valor de uma constante
2) Ler os valores reais da Matriz_A
3) Dividir pela constante o valor de cada elemento da Matriz_A e atribuir o resultado à Matriz_B
4) Escrever num arquivo a Matriz_B identificando os índices de cada elemento
Exercício 10.2
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores reais da Matriz_A
2) Calcular a exponencial do valor de cada elemento da Matriz_A e atribuir o resultado à Matriz_B
3) Escrever num arquivo a Matriz_B identificando os índices de cada elemento
Exercício 10.3
Editar um programa-fonte em FORTRAN para calcular o produto de duas matrizes [A] x [B], executando
o seguinte algoritmo (passos):
1) Ler os seguintes dados (suficientes para resolver o problema):
a) número de linhas da Matriz_A
b) número de colunas da Matriz_A
c) número de colunas da Matriz_B
d) Valores dos elementos da Matriz_A
e) Valores dos elementos da Matriz_B
2) Calcular o valor de cada elemento da Matriz_C que resulta do produto da Matriz_A pela Matriz_B;
para fazer isso, sugere-se analisar o produto literal entre uma matriz 2x2 com outra 2x1; depois, uma
3x2 com outra 2x2; deduzir o algoritmo e implementá-lo
3) Escrever num arquivo todos os dados lidos e a Matriz_C identificando todas as variáveis e elementos
4) Calcular a Matriz_D através da seguinte linha inserida dentro do programa-fonte:
Matriz_D = MATMUL ( Matriz_A, Matriz_B )
OBJETIVOS DO CAPÍTULO
• Aprender a utilizar o aplicativo Wgnuplot para fazer gráficos
• Aprender a utilizar o aplicativo Wgnuplot interativamente com um programa em FORTRAN
1) O Wgnuplot é um software livre utilizado para fazer gráficos bi e tridimensionais. Um manual básico
sobre ele está disponível em ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/Wgnuplot.pdf
2) Para iniciar sua utilização, basta clicar duas vezes sobre o arquivo Wgnuplot.exe ou Application.
O resultado deve ser o mostrado na Figura 11.1.
3) Informações detalhadas sobre a utilização do Wgnuplot podem ser vistas no menu principal do
programa, na opção Help, Index
4) Informações detalhadas sobre os comandos do Wgnuplot podem ser vistas no menu principal do
programa, na opção Help, Index, commands. Escolher, por exemplo, o comando plot.
5) Para gerar um gráfico, devem ser executados os comandos adequados na chamada “linha de
comando” do aplicativo Wgnuplot, que é a linha indicada por “gnuplot>” na Figura 11.1, e onde o
cursor fica após ser acionado o programa.
Figura 11.2 Inserção do comando plot sin(x) na linha de comando do aplicativo Wgnuplot.
Figura 11.3 Gráfico da função seno conforme o comando do item 6 da seção 11.2.
8) O comando set yrange[y1:y2] é usado para definir o intervalo dos valores das ordenadas, isto é, y,
mostrado no gráfico, onde y1 e y2 são os valores mínimo e máximo, respectivamente. Por exemplo,
para definir o intervalo dos valores de y entre os números 0 e 1, na linha de comando do Wgnuplot,
deve-se digitar set yrange[0:1]. Em seguida, clicar na tecla Enter. Para visualizar o resultado,
digitar replot e, em seguida, clicar na tecla Enter.
1) O aplicativo Wgnuplot pode ser usado para fazer gráfico de um arquivo de dados. Isso será
exemplificado com o arquivo dados.txt. Para criá-lo com o aplicativo Notepad, executar o seguinte:
a) Start, Programs, Accessories, Notepad
b) Dentro do espaço de edição do Notepad, digitar os seguintes números em duas colunas separadas
por pelo menos um espaço em branco:
0 0
1 1
2 4
3 9
4 7
5 0
c) File, Save
d) Na janela “Save As”, dentro do campo “File Name”, digitar dados.txt
e) Ainda na janela “Save As”, dentro do campo “Save in:”, selecionar o diretório do projeto. Em
seguida, clicar sobre o botão Save.
f) No aplicativo Notepad, executar File, Exit
2) Num arquivo de dados, o aplicativo Wgnuplot interpreta a primeira coluna como os dados do eixo x
(abscissas) e a segunda, do eixo y (ordenadas).
3) Inicializar o aplicativo Wgnuplot clicando duas vezes sobre o arquivo Wgnuplot.exe ou Application
Figura 11.5 Gráfico resultante dos comandos usados nos itens 6 a 13 da seção 11.2.
5) O comando set data style linespoints é utilizado para colocar um símbolo (círculo, quadrado etc) em
cada par x-y dos dados e unir os pontos com retas entre eles. Na linha de comando do aplicativo
Wgnuplot, digitar set data style linespoints e, em seguida, clicar na tecla Enter.
6) Para gerar o gráfico com as coordenadas x-y do arquivo dados.txt, na linha de comando do aplicativo
Wgnuplot, digitar plot “dados.txt” e, em seguida, clicar na tecla Enter. Deverá surgir o gráfico
correspondente aos comandos usados nesta seção, que é mostrado na Figura 11.6.
7) Encerrar o Wgnuplot com File, Exit
1) O aplicativo Wgnuplot também pode ser usado para fazer gráfico de um arquivo de dados utilizando
um arquivo com os comandos do próprio Wgnuplot. Isso facilita muito a geração de gráficos de forma
automatizada. A seguir, este novo procedimento é aplicado ao mesmo exemplo da seção anterior
utilizando o arquivo comandos.txt. Para criá-lo com o aplicativo Notepad, executar o seguinte:
a) Start, Programs, Accessories, Notepad
b) Dentro do espaço de edição do Notepad, digitar os seguintes comandos do Wgnuplot:
set xlabel “x”
set ylabel “y”
set title “Teste do Wgnuplot”
set grid
set data style linespoints
plot “dados.txt”
c) File, Save
d) Na janela “Save As”, dentro do campo “File Name”, digitar comandos.txt
11.5 programa11.f90
1) Nesta seção será usado o mesmo projeto criado na seção 11.1. Portanto, no Fortran, seguindo o
procedimento-padrão, criar e inserir no projeto o programa-fonte programa11.f90
2) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 11.1.
3) Objetivos do programa:
a) Gerar um arquivo com as coordenadas x e y de uma curva
b) Plotar esta curva com o aplicativo Wgnuplot
4) Comentários sobre o programa:
a) O uso dos comandos USE e SYSTEM já foi explicado na seção 5.3 do capítulo 5.
b) O comando SYSTEM vinha sendo usado para que o aplicativo Notepad abrisse arquivos com
resultados dos programas. No programa11.f90 ele também é usado para acionar o aplicativo
Wgnuplot e gerar um gráfico, com o procedimento visto na seção 11.4.
c) O arquivo de comandos do Wgnuplot utilizado no programa é aquele criado na seção anterior,
chamado comandos.txt.
5) Algoritmo do programa:
a) Unir a biblioteca PORTLIB ao programa para usar o comando SYSTEM
REAL X, Y
INTEGER PONTO, PONTOS, VER
DO PONTO = 1, PONTOS
X = PONTO - 1
Y = X**3
WRITE(7,40) X, Y
40 FORMAT( 2 ( 1PE10.2 ) )
END DO
CLOSE(7)
END
d) Fechar o aplicativo Notepad, com File, Exit. Deve surgir o gráfico mostrado na Figura 11.9.
9) Até entender, analisar os resultados do programa11.f90, mostrados nas Figura 11.7 a 11.9,
considerando cada linha do programa-fonte e as explicações descritas nas seções anteriores deste
capítulo.
10) Executar novamente o programa com outro número de pontos.
11) Encerrar a sessão seguindo o procedimento-padrão.
Exercício 11.1
Adaptar o programa11.f90 para que ele gere o gráfico y versus x onde y = logaritmo decimal de x
Exercício 11.2
Adaptar o programa11.f90 para que ele gere o gráfico y versus x onde y = cosseno hiperbólico de x
OBJETIVOS DO CAPÍTULO
• Conceitos de: sub-rotina, programa-principal, projeto com diversos programas-fonte, passagem de
argumentos
• Comandos do FORTRAN: PROGRAM, EXTERNAL, SUBROUTINE, CALL, CONTAINS
12.1 programa12a
EXTERNAL ROTINA1
REAL A, B, C
CALL SOMA ( A, B, C )
utilidade prática nenhuma. Deve-se perceber que ele é diferente do nome do projeto e do nome do
programa-fonte.
REAL X, Y, Z
Z = X + Y
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é
necessário digitar 1, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*)
"Entre com o valor de B" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B,
resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é
necessário digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, é apresentado o resultado da soma das variáveis A e B, calculado dentro da sub-
rotina SOMA.
12.2 programa12b
EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL A, B, C
CALL SOMA ( A, B, C )
REAL X, Y, Z
Z = X + Y
SUBROUTINE FATORIAL ( N )
INTEGER I, N, FAT
FAT = 1
IF ( N < 0 ) THEN
WRITE(*,*) "Nao existe fatorial de ", N
ELSE
DO I = 2, N
FAT = FAT * I
END DO
END IF
6) Objetivos do programa:
a) Implementar um programa-fonte com duas sub-rotinas
b) Utilizar duas sub-rotinas externas ao programa-principal
7) Comentários sobre o programa:
a) Um programa-fonte pode ser constituído por uma ou várias sub-rotinas. Um exemplo é o
programa-fonte rotinas2.f90 que contém duas sub-rotinas.
12.3 programa12c
EXTERNAL ROTINA3
CALL OUTRAS
EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL A, B, C
CALL SOMA ( A, B, C )
12.4 programa12d
USE MSIMSLMS
CALL OUTRAS
CONTAINS
! -------------------------------------------------------------------
SUBROUTINE OUTRAS
INTEGER INTEIRO
REAL A, B, C
CALL SOMA ( A, B, C )
! -------------------------------------------------------------------
SUBROUTINE SOMA ( X, Y, Z )
REAL X, Y, Z
Z = X + Y
! -------------------------------------------------------------------
SUBROUTINE FATORIAL ( N )
INTEGER I, N, FAT
FAT = 1
IF ( N < 0 ) THEN
WRITE(*,*) "Nao existe fatorial de ", N
ELSE
DO I = 2, N
FAT = FAT * I
END DO
END IF
! -------------------------------------------------------------------
12.5 EXERCÍCIO
Exercício 12.1
Alterar o programa12d, da seção 12.4, da seguinte forma:
1) Adaptar a sub-rotina FATORIAL e sua chamada na sub-rotina OUTRAS para que o valor do fatorial
seja passado a sub-rotina OUTRAS
2) Implementar a sub-rotina ESCREVE para escrever num arquivo os resultados das variáveis A, B, C,
INTEIRO e fatorial. Esta nova sub-rotina deverá ser chamada dentro da sub-rotina OUTRAS.
3) Implementar a sub-rotina ARQUIVO para mostrar, com o aplicativo Notepad, o conteúdo do arquivo
criado pela sub-rotina ESCREVE. A sub-rotina ARQUIVO deverá ser chamada pela sub-rotina
OUTRAS, após a chamada da sub-rotina ESCREVE.
OBJETIVOS DO CAPÍTULO
• Conceitos de: variáveis de precisão simples e dupla, variáveis do tipo real simples e dupla, mistura de
variáveis do tipo inteiro com real simples e real dupla
• Funções matemáticas intrínsecas e formatos de edição para variáveis do tipo real dupla
• Comandos do FORTRAN: REAL, REAL*4, REAL(4), REAL*8, REAL(8), DOUBLE PRECISION e
IMPLICIT NONE
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
13.1 programa13a.f90
1) Objetivos do programa:
a) Definir uma variável do tipo real de dupla precisão usando o comando REAL*8
b) Comparar a precisão de variáveis do tipo real simples e dupla
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13a
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa13a.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 13.1.
5) Comentários sobre o programa:
a) No capítulo 3 foram abordadas as variáveis do tipo real. Elas são usadas para definir variáveis do
tipo real, isto é, variáveis que podem guardar ou armazenar na memória do computador números
reais, positivos ou negativos, como 1.0, –1.0, 1.1, 3.1416 ou –0.003. Para definir uma variável do
tipo real num programa usa-se o comando REAL. As variáveis definidas com o comando REAL
podem guardar na memória do computador valores no intervalo aproximado de 1.17e-38 a
3.40e+38 e a precisão é de 6 casas decimais. Estas variáveis também podem ser chamadas de reais
simples ou de precisão simples.
b) O novo comando REAL*8 é usado para definir variáveis do tipo real dupla ou de precisão dupla.
As variáveis definidas com o comando REAL*8 podem guardar na memória do computador
valores no intervalo aproximado de 2.22e-308 a 1.79e+308 e a precisão é de 15 casas decimais.
END
9) Executar novamente o programa com o valor 123456789 para as duas variáveis e analisar os
resultados.
13.2 programa13b.f90
1) Objetivos do programa:
a) Usar diversas formas para definir variáveis reais simples e dupla
b) Realizar cálculos elementares envolvendo variáveis do tipo inteiro, real simples e real dupla
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13b
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa13b.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 13.2.
5) Comentários sobre o programa:
a) As variáveis do tipo real simples podem ser definidas através dos comandos REAL, REAL*4 e
REAL(4). Exemplos são as definições das variáveis A, B e C.
b) As variáveis do tipo real dupla podem ser definidas através dos comandos REAL*8, REAL(8) e
DOUBLE PRECISION. Exemplos são as definições das variáveis E, F e G.
c) Os cálculos das variáveis D, B e C são exatamente os mesmos mostrados no programa03d.f90 do
capítulo 3, seção 3.2, para explicar as conseqüências de misturar variáveis do tipo inteiro e real
simples num cálculo. Estas mesmas explicações valem para as variáveis reais dupla F e G.
d) Quando se atribui uma variável real simples a uma real dupla, esta tem sua precisão deteriorada
para real simples. Um exemplo é o cálculo da variável E. Isso deve sempre ser evitado. Se o
objetivo é usar precisão dupla num programa, todas as variáveis e os cálculos devem envolver
precisão dupla, exceto em alguns tipos de cálculo com variáveis inteiras.
6) Executar Build, Compile para compilar o programa
7) Gerar o programa-executável fazendo Build, Build.
8) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A.
9) Analisar os resultados mostrados na Figura 13.2. Deve-se notar a diferença de precisão no
arredondamento do cálculo das variáveis C e G. Também deve-se notar a deterioração da precisão da
REAL A
REAL*4 B
REAL(4) C
REAL*8 E
REAL(8) F
DOUBLE PRECISION G
D = A
B = 1 / D
C = 1.0 / D
E = A
F = 1 / D
G = 1.0 / D
END
10) Executar novamente o programa com outros valores para a variável A e analisar os resultados.
11) No Fortran, para fechar o projeto atual, executar File, Close Workspace
13.3 programa13c.f90
1) Objetivos do programa:
a) Mostrar a importância de serem definidas todas as variáveis de um programa
b) Utilizar o comando IMPLICIT NONE
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13c
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa13c.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 13.2, isto é, copiar o programa13b.f90 do projeto anterior.
5) Eliminar a primeira linha do programa, ou seja, INTEGER D.
6) Executar Build, Compile para compilar o programa. Mesmo a variável D não tendo sido definida,
não ocorre erro de compilação. Quando uma variável não é definida, por default, assume-se que todas
as variáveis iniciadas pelas letras I até N, em ordem alfabética, são do tipo inteiro, e as demais são do
tipo real simples.
7) Gerar o programa-executável fazendo Build, Build.
8) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A. Em princípio,
os mesmos resultados mostrados na Figura 13.2 deveriam ser obtidos. Porém, pode-se notar na
Figura 13.3 que isso não ocorre, ressaltando-se: a variável D passou a ser uma variável real simples;
com isso, foram alterados os valores das variáveis B, C, F e G.
9) Incluir na primeira linha do programa13c.f90 o comando IMPLICIT NONE. Ele deve ser
colocado antes de qualquer declaração de tipo de variável. Recomenda-se fortemente sempre usar o
comando IMPLICIT NONE porque ele obriga o programador a declarar explicitamente os tipos de
10) Executar Build, Compile para compilar a nova versão do programa. Deve-se notar que agora
ocorrerá erro de compilação, apontando que a variável D não foi declarada.
11) Incluir a declaração da variável D como sendo do tipo inteiro, conforme é mostrado na Tabela
13.3.
12) Executar Build, Compile para compilar o programa.
13) Gerar o programa-executável fazendo Build, Build.
14) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A. Agora os
resultados são os mesmos mostrados na Figura 13.2, conforme esperado.
15) No Fortran, para fechar o projeto atual, executar File, Close Workspace
INTEGER D
REAL A
REAL*4 B
REAL(4) C
REAL*8 E
REAL(8) F
DOUBLE PRECISION G
E = A
F = 1 / D
G = 1.0 / D
END
13.4 programa13d.f90
1) Objetivos do programa:
a) Usar funções matemáticas intrínsecas do FORTRAN com variáveis reais do tipo dupla
b) Usar formatos de edição com variáveis reais do tipo dupla
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13d
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa13d.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 13.4.
A4 = A8
WRITE(9,*) "A4 = A8 =", A4
B4 = ABS(A4)
B8 = DABS(A8)
WRITE(9,*) "B4 = Módulo com ABS(A4) =", B4
WRITE(9,*) "B8 = Módulo com DABS(A8) =", B8
C4 = LOG10(B4)
C8 = DLOG10(B8)
WRITE(9,*) "C4: Logaritmo decimal com LOG10(B4) =", C4
WRITE(9,*) "C8: Logaritmo decimal com DLOG10(B8) =", C8
Pi4 = ACOS(-1.0e0)
Pi8 = DACOS(-1.0d0)
WRITE(9,*) "Pi com ACOS(-1.0e0) = ", Pi4
WRITE(9,*) "Pi com DACOS(-1.0d0) = ", Pi8
CLOSE(9)
END
c) A lista completa de funções matemáticas intrínsecas do FORTRAN pode ser vista no manual do
Fortran. Para acessá-lo, dentro da subjanela do lado esquerdo, deve-se executar: clicar uma vez
sobre o símbolo ?InfoView; e acessar as opções Reference, Procedures, Numeric Procedures e
as opções Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic
Procedures.
d) Os tipos de formatos de edição usados com variáveis do tipo real simples também podem ser
usados com variáveis do tipo real dupla. Estes formatos foram vistos no capítulo 6, seção 6.3. Um
outro formato que pode ser conveniente é 1PEX.YEZ, onde a terminação EZ indica expoente e Z
o número de algarismos para o expoente. Por exemplo, no programa13d.f90 usa-se o formato
1PE15.2E3.
e) Nos argumentos de funções intrínsecas para variáveis do tipo real dupla deve-se definir os
números usando-se a letra D (ou d) em vez de E (ou e) (das variáveis reais simples) para
13.5 EXERCÍCIOS
Exercício 13.1
Para testar as operações matemáticas básicas, refazer o programa03e.f90, do capítulo 3, seção 3.3, usando
variáveis do tipo real dupla em vez de real simples.
Exercício 13.3
Escrever as expressões em linguagem FORTRAN que correspondem às seguintes expressões algébricas,
onde A, B e L são números reais de precisão dupla, e I e J são números inteiros:
B + 5
a) A =
100
1
b) A = + 3
B
10
1 1
c) L = I2 +
3− I J3
Exercício 13.4
1) Executar o programa13d.f90 com A8 = 1.2e+308. Deve-se notar que o programa terá problema
durante a execução. Por que isso ocorre?
2) Implementar uma nova versão do programa13d.f90 com a eliminação de tudo relacionado às variáveis
reais de precisão simples.
a) Gerar o executável desta nova versão e executá-lo com A8 = 1.2e+308. Deve-se notar que agora o
programa é executado sem nenhum problema. Por que isso ocorre? Observar o que acontece com a
representação dos resultados através dos formatos usados, principalmente com relação aos
expoentes.
b) Executar novamente o programa com A8 = 2.2e-308.
c) Executar novamente o programa com A8 = 2.0e+308. O que acontece? Por quê?
d) Executar novamente o programa com outros valores para A8.
OBJETIVOS DO CAPÍTULO
• Conceitos de: arquivo de entrada, arquivo interno, arquivo texto, arquivo binário, dispositivo e nome
de arquivo genéricos
• Comandos do FORTRAN: uso avançado de OPEN, WRITE e SYSTEM
• No comando OPEN, usar os parâmetros FORMATTED, UNFORMATTED, REWIND e APPEND
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
14.1 programa14a.f90
Pi = DACOS(-1.0d0)
OPEN(9,file="saida14a.txt")
WRITE(9,11) UNIT, Pi
CLOSE(9)
END
14.2 programa14b.f90
1) Objetivos do programa:
(a) Entrada de dados através de janela DOS;
(b) escrever resultados num arquivo cujo nome e o número do dispositivo são genéricos e definidos
pelo usuário através dos dados do programa; e
(c) abrir o arquivo de resultados de nome genérico com o aplicativo Notepad.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa14b
Pi = DACOS(-1.0d0)
CLOSE(UNIT)
END
dispositivo que identifica o arquivo, é usado uma variável chamada UNIT, que é um dado do
programa.
(d) Na linha VER = SYSTEM( TEXTO ), deve-se notar que no comando SYSTEM, no lugar de um
texto específico, como era feito antes, por exemplo no programa14a.f90, é usado uma variável
chamada TEXTO.
6) Executar Build, Compile para compilar o programa.
7) Gerar o programa-executável fazendo Build, Build.
8) Executar o programa através de Build, Execute com:
Unidade de saída = 8
Nome do arquivo de saída = saida.txt
O resultado deve ser o mostrado na Figura 14.2.
14.3 programa14c.f90
14.4 programa14d.f90
1) Objetivos do programa:
(a) ler os dados do programa de um arquivo, em vez de usar a janela DOS; e
READ(1,*) UNIT
CLOSE(1)
Pi = DACOS(-1.0d0)
CLOSE(UNIT)
END
(c) Nas linhas READ(1,*) UNIT e READ(1,*) SAIDA os dois dados são lidos, variáveis UNIT e
SAIDA. Deve-se notar que são dois comandos READ, cada um sendo usado para ler uma única
variável. Assim, após o programa ler o conteúdo da variável UNIT na primeira linha do arquivo
“dados.txt”, tudo que estiver nesta linha após o valor de UNIT não é considerado pelo programa.
Portanto, podem ser inseridos comentários nos arquivos de dados para ficar claramente definido
ao que corresponde cada dado. O mesmo se aplica ao valor da variável SAIDA na segunda linha
do arquivo “dados.txt”; o que está após este dado, na mesma linha, não é considerado pelo
programa.
(d) Recomenda-se sempre fazer isso: um dado por linha e, em seguida, na mesma linha, um
comentário para informar o que significa a variável. Além disso, nunca se deve usar formato para
ler dados; este é o motivo do asterisco nos dois comandos READ. Os formatos devem ser usados
apenas para escrever resultados.
(e) Todos os comentários já feitos nos capítulos anteriores e neste sobre o comando OPEN, para
arquivos de resultados ou de saída, também valem para arquivos de entrada ou de dados.
6) Executar Build, Compile para compilar o programa.
7) Gerar o programa-executável fazendo Build, Build.
dispositivo associado a um arquivo de resultados ou de dados também pode ser uma variável do
tipo caracter.
(b) Na linha WRITE(TEXTO2,*) UNIT do programa14e.f90, define-se a variável TEXTO2, do tipo
caracter, como o dispositivo no qual será escrito o conteúdo da variável UNIT, que é do tipo
inteiro.
(c) Na linha WRITE(TEXTO3,*) Pi do programa14e.f90, define-se a variável TEXTO3, do tipo
caracter, como o dispositivo no qual será escrito o conteúdo da variável Pi, que é do tipo real
dupla.
(d) Na linha WRITE(TEXTO4,*) TEXTO // TEXTO3 do programa14e.f90, define-se a variável
TEXTO4, do tipo caracter, como o dispositivo no qual será escrito o conteúdo da variável
TEXTO concatenada com o conteúdo da variável TEXTO3, sendo ambas do tipo caracter.
(e) Na linha READ(TEXTO3,*) TEXTO5 do programa14e.f90, define-se a variável TEXTO3, do tipo
caracter, como o dispositivo do qual será lido o conteúdo da variável TEXTO5, que é do tipo
caracter.
WRITE(TEXTO2,*) UNIT
WRITE(TEXTO3,*) Pi
READ(TEXTO3,*) TEXTO5
CLOSE(UNIT)
END
9) Executar novamente o programa através de Build, Execute com outros dados. Analisar o novo
resultado.
10) Encerrar a sessão seguindo o procedimento-padrão.
14.6 EXERCÍCIOS
Exercício 14.1
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exercício 13.1 atendendo:
(a) um arquivo para entrar os dados do programa;
(b) no início da execução do programa, abrir automaticamente o arquivo de dados com o aplicativo
Notepad;
(c) um arquivo para escrever os resultados do programa, com o nome do arquivo sendo definido pelo
usuário;
(d) no final da execução do programa, abrir automaticamente o arquivo de resultados com o aplicativo
Notepad.
Exercício 14.2
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exercício 13.2 atendendo aos mesmos 4
itens do exercício 14.1.
Exercício 14.4
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o programa da seção 12.4, Tabela 12.7,
atendendo aos mesmos 4 itens do exercício 14.1.
Exercício 14.5
Implementar uma nova versão do programa14d.f90 para que:
(a) o nome do arquivo de dados seja definido pelo usuário; e
(b) no início da execução do programa, o arquivo de dados seja aberto automaticamente com o aplicativo
Notepad.
OBJETIVOS DO CAPÍTULO
• Inicializar variáveis e constantes junto com suas definições
• Versões DEBUG e RELEASE de um programa-executável
• Comandos do FORTRAN: PARAMETER, Formato A<X>
• Função do FORTRAN: TIMEF
• Comandos do DOS: MKDIR, COPY, ERASE, CD, RENAME, “arquivo”.BAT
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
15.1 programa15a.f90
1) Objetivos do programa:
(a) usar os novos comandos do FORTRAN: PARAMETER e formato A<X>
(b) ao definir variáveis, inicializar seus valores; e
(c) escrever variáveis do tipo caracter com tamanho exato de seu conteúdo, usando o comando
FORMAT.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa15a
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa15a.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 15.1.
INTEGER :: UNIT = 20
READ(1,*) COMENTARIO
READ(1,*) SAIDA
CLOSE(1)
WRITE(UNIT,10) UNIT, Pi
10 FORMAT( /, 5X, "UNIT = ", I4, &
2/, 5X, "Pi = ", 1PE25.15 )
WRITE(UNIT,11) COMENTARIO
11 FORMAT( /, A50, " = COMENTARIO" )
X = LEN(TRIM(ADJUSTL(COMENTARIO)))
WRITE(UNIT,12) TRIM(ADJUSTL(COMENTARIO))
12 FORMAT( /, A<X>, " = COMENTARIO" )
CLOSE(UNIT)
END
9) Executar o programa através de Build, Execute. O resultado deve ser o mostrado na Figura 15.2.
10) Executar novamente o programa com outros dados e analisar os novos resultados.
11) No Fortran, para fechar o projeto atual, executar File, Close Workspace.
15.2 programa15b.f90
INTEGER :: UNIT = 20
READ(1,*) PASSOS
READ(1,*) SAIDA
T1 = TIMEF()
SOMA = 0.0D0
DO I = 1, PASSOS
SOMA = SOMA + I
END DO
T2 = TIMEF()
T1 = TIMEF()
SOMA = 0.0D0
DO I = 1, PASSOS
SOMA = SOMA + I
END DO
T2 = TIMEF()
CLOSE(UNIT)
END
Figura 15.4 Resultado do programa15b.f90 para os dados da Figura 15.3, versão DEBUG.
10) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por
exemplo, PASSOS = 10 milhões, 1 milhão e 1 bilhão.
11) Verificar se dentro do diretório do projeto existe um subdiretório chamado DEBUG. Se não,
isto é, se o diretório existente for chamado RELEASE, onde se lê DEBUG, nos itens 12 a 14, abaixo,
deve-se ler RELEASE e vice-versa.
12) Mudar a versão do programa para RELEASE. Para fazer isso, executar Build, Set Default
Configuration..., escolher a opção RELEASE, clicar no botão OK. Depois, executar Build,
Figura 15.5 Resultado do programa15b.f90 para os dados da Figura 15.3, versão RELEASE.
15) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por
exemplo, PASSOS = 10 milhões, 1 milhão e 1 bilhão.
16) No Fortran, para fechar o projeto atual, executar File, Close Workspace.
15.3 programa15c.f90
READ(1,*) COMENTARIO
READ(1,*) SAIDA
CLOSE(1)
CLOSE(UNIT)
CLOSE (UNIT)
! fim
END
15.4 EXERCÍCIOS
Exercício 15.1
Adaptar o programa15a.f90, Tabela 15.1, para:
Exercício 15.2
Adaptar o programa15b.f90, Tabela 15.2, para usar a função DTIME junto com TIMEF e comparar o
tempo de CPU medido por cada função.
Exercício 15.3
Adaptar o programa15b.f90, Tabela 15.2, para que a variável SOMA seja do tipo inteiro. Notar a redução
do tempo de CPU que ocorre.
Exercício 15.4
Adaptar o programa15b.f90, Tabela 15.2, para obter e escrever o tempo de CPU gasto entre a primeira e a
última chamada da função TIMEF.
Exercício 15.5
Adaptar o programa15b.f90, Tabela 15.2, para incluir, antes da última chamada da função TIMEF, a
instrução
READ(*,*) “Espere alguns segundos e pressione a tecla ENTER”
Analisar o efeito desta instrução vazia no tempo de CPU.
Exercício 15.6
Adaptar o programa15c.f90, Tabela 15.3, visando generalizar o nome do diretório
“C:\TEMP\FORTRAN\”
para qualquer nome que o usuário defina através do arquivo de dados.
OBJETIVOS DO CAPÍTULO
• Estimar e verificar a memória computacional necessária para executar um programa
• Utilizar sub-rotina recursiva
• Controlar o fluxo de informações para dentro e para fora de sub-rotinas
• Comandos do FORTRAN: DEALLOCATE, RECURSIVE, INTENT(IN,OUT,INOUT)
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
16.1 programa16a.f90
1) Objetivos do programa:
(a) mostrar como estimar a memória computacional necessária para executar um programa; e
(b) usar um novo comando do FORTRAN: DEALLOCATE.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa16a
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa16a.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 16.1.
5) Comentários sobre o programa:
(a) O comando DEALLOCATE é usado para eliminar da memória do computador variáveis para as
quais foi reservado memória por meio do comando ALLOCATE. Para usá-lo basta a palavra
DEALLOCATE e, dentro de parênteses, as diversas variáveis separadas por vírgula. Não é
necessário indicar novamente o tamanho das variáveis, pois isso já é conhecido do comando
ALLOCATE. O comando DEALLOCATE só pode ser usado com variáveis cuja memória foi
alocada com o comando ALLOCATE.
(b) Na linha DEALLOCATE ( A ) a variável A, do tipo inteiro, com N elementos, está sendo
eliminada da memória do computador.
(c) A estimativa da memória necessária para executar um programa pode ser obtida através da
seguinte equação:
onde Ninteiro, Nreal simples e Nreal dupla representam o número total de elementos de conjuntos ou
matrizes de variáveis do tipo inteiro, real simples e real dupla, respectivamente; Ncaracter
representa o número total de elementos de variáveis do tipo caracter que tem comprimento ou
número de caracteres igual a L. Dentro do último parênteses devem ser incluídos os produtos de
outras variáveis do tipo caracter com outros comprimentos. Os valores 4, 8 e 1 representam o
número de bytes que cada um dos tipos de variáveis ocupa de memória para um único elemento.
O valor 1024 é um fator usado para converter o número de bytes em kilobytes (kB).
READ(1,*) N
READ(1,*) SAIDA
CLOSE(1)
A = 1
M1 = N*4.0 / 1024
M2 = N*8.0 / 1024
M3 = N*1.0*10 / 1024
M4 = M1 + M2 + M3
CLOSE(UNIT)
DEALLOCATE ( A )
DEALLOCATE ( B )
DEALLOCATE ( C )
END
13) A Figura 16.4 mostra a memória estimada com a Eq. (16.1) para as variáveis A, B e C do
programa16a.exe. Na Tabela 16.2 tem-se a comparação entre a memória estimada (Figura 16.4) e a
memória efetivamente usada, que foi obtida do Task Manager, nos subitens (d) a (g) do item 12,
acima.
14) Executar novamente o programa com outros valores para N e analisar os novos resultados.
15) No Fortran, para fechar o projeto atual, executar File, Close Workspace.
16.2 programa16b.f90
1) Objetivos do programa:
(a) utilizar sub-rotina recursiva; e
(b) usar um novo comando do FORTRAN: RECURSIVE
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa16b
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa16b.f90
(b) A chamada da sub-rotina é feita da forma já descrita no capítulo 12, isto é, usando o comando
CALL seguido do nome da sub-rotina. Um exemplo é dado no programa16b.f90 na linha CALL
TESTE
SOMA = 0
MENOS = 0
DO I = 1, 2
WRITE(*,*) "MAIN/ciclo: I,K,SOMA,MENOS=", I, K, SOMA, MENOS
K = 4
CALL TESTE
END DO
CONTAINS
! -------------------------------------------------------------------
IF ( K == 1 ) THEN
ELSE
SOMA = SOMA + 1
END IF
! -------------------------------------------------------------------
16.3 programa16c.f90
1) Objetivos do programa:
(a) controlar o fluxo de informações para dentro e para fora de sub-rotinas; e
(b) usar um novo comando do FORTRAN: INTENT com parâmetros IN, OUT e INOUT.
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 16.4.
5) Comentários sobre o programa:
(a) O uso do comando IMPLICIT NONE no programa-principal obriga que sejam declaradas
explicitamente todas as variáveis usadas no programa-principal e em todas as sub-rotinas do
mesmo programa. Caso contrário, ocorrerá erro de compilação.
(b) Todas as variáveis definidas no programa-principal são válidas dentro das sub-rotinas do
programa. Elas são chamadas de variáveis globais. Por exemplo, as variáveis A, B, C, D, E e F
do programa16c.f90, definidas na linha INTEGER A, B, C, D, E, F, são variáveis globais do
programa.
(c) As variáveis definidas dentro de uma sub-rotina são válidas somente dentro da própria sub-
rotina. Elas são chamadas de variáveis locais. Seus valores ou conteúdos podem ser passados
para outras sub-rotinas ou para o programa-principal através dos argumentos da sub-rotina. Por
exemplo, as variáveis R e S do programa16c.f90, definidas na linha INTEGER R, S, são
variáveis locais da sub-rotina TESTE.
(d) Todas as atribuições feitas a variáveis globais são reconhecidas dentro das sub-rotinas do
programa.
(e) Todas as atribuições feitas a variáveis locais não são reconhecidas fora das sub-rotinas do
programa.
IMPLICIT NONE
INTEGER A, B, C, D, E, F
C = 100
D = A
E = B
F = A + B
CALL SOMA ( A, B, C, D, E )
! -------------------------------------------------------------------
CONTAINS
! -------------------------------------------------------------------
SUBROUTINE SOMA ( X, Y, Z, T, R )
INTEGER, INTENT(IN) :: X, Y
INTEGER, INTENT(OUT) :: Z
INTEGER, INTENT(INOUT) :: T
INTEGER R, S
S = 50
Z = X + Y
T = T + 10
R = R + 10
F = 2 * F
! -------------------------------------------------------------------
(f) O comando INTENT é usado para controlar o fluxo de informações para dentro e para fora das
sub-rotinas. Ele é usado quando se define cada variável empregada como argumento das sub-
rotinas.
(g) O comando INTENT é utilizado com três parâmetros (IN, OUT e INOUT) que definem o sentido
do fluxo da informação.
(h) O comando INTENT(IN) permite que a variável apenas receba informação de fora da sub-rotina.
Um exemplo é dado no programa16c.f90 na linha INTEGER, INTENT(IN) :: X, Y. As
variáveis X e Y só podem receber informação de fora da sub-rotina TESTE. A tentativa de
atribuir valor a elas dentro da sub-rotina gerará erro de compilação. Mas elas podem ser
empregadas em expressões dentro da sub-rotina, como na linha Z = X + Y
(i) O comando INTENT(OUT) permite que a variável apenas envie informação para fora da sub-
rotina. Um exemplo é dado no programa16c.f90 na linha INTEGER, INTENT(OUT) :: Z. A
variável Z só pode enviar informação para fora da sub-rotina TESTE.
Exercício 16.1
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos
elementos são do tipo inteiro, com X1 por Y1 elementos.
Exercício 16.2
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos
elementos são do tipo real dupla, com X2 por Y2 elementos.
Exercício 16.3
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos
elementos são do tipo caracter, cada um com 100 caracteres, com X3 por Y3 elementos.
Exercício 16.4
Juntar as matrizes dos exercícios 16.1 a 16.3 num único programa para estimar e verificar a memória
computacional total que é necessária para as três matrizes.
Exercício 16.5
Adaptar a sub-rotina FATORIAL, da Tabela 12.4, do capítulo 12, para ser uma sub-rotina do tipo
recursiva. E implementar um programa-principal para ela.
Exercício 16.6
Adaptar o programa12d, Tabela 12.7, do capítulo 12, para:
(a) usar onde pertinente o comando INTENT com IN, OUT e INOUT;
(b) usar o comando IMPLICIT NONE no programa-principal;
(c) ter uma sub-rotina com a finalidade de ler os dados de um arquivo;
(d) ter uma sub-rotina com a finalidade de escrever os resultados num arquivo; e
(e) ter uma sub-rotina com a finalidade de abrir os arquivos de dados e de saída com o aplicativo
Notepad.
OBJETIVOS DO CAPÍTULO
• Utilizar módulos
• Comandos do FORTRAN: MODULE, END MODULE, PRIVATE, PUBLIC
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
17.1 programa17a.f90
1) Objetivos do programa:
(a) exemplificar o uso e as características básicas de módulos em FORTRAN; e
(b) usar dois novos comandos do FORTRAN: MODULE, END MODULE.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa17a
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte dados.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 17.1.
5) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte saida.f90
6) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 17.2.
7) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
principal.f90
8) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 17.3.
9) Comentários sobre o programa:
(a) Um módulo é praticamente igual a um programa-principal. A maior diferença é que num módulo
não se pode ter comandos executáveis antes do comando CONTAINS, ao contrário do que
ocorre num programa-principal.
(b) A definição de módulo em FORTRAN deve seguir a sintaxe mostrada na Tabela 17.4. O nome
do módulo segue as regras válidas para variáveis em FORTRAN, não podendo ser igual a
nenhum outro nome de módulo, variável ou sub-rotina do programa. No caso de não haver sub-
IMPLICIT NONE
REAL*8 I, J
CONTAINS
SUBROUTINE LE_DADOS
USE DADOS
IMPLICIT NONE
REAL*8 K
CONTAINS
SUBROUTINE CALCULOS
K = I + J
SUBROUTINE RESULTADOS
USE PORTLIB
INTEGER VER
INTEGER C
CHARACTER(20) B
B = "teste de fortran"
C = 7
WRITE(1,3) I, J, K
3 FORMAT( 2/, "I = ", 1PE10.3, &
2/, "J = ", 1PE10.3, &
2/, "K = ", 1PE10.3 )
CLOSE(1)
USE SAIDA
IMPLICIT NONE
CALL LE_DADOS
CALL CALCULOS
CALL RESULTADOS
17.2 programa17b.f90
1) Objetivo do programa: entender o uso de módulos num programa composto por quatro módulos.
17.3 programa17c.f90
1) Objetivos do programa:
(a) definir variáveis públicas e privadas em módulos;
(b) usar dois novos comandos do FORTRAN: PUBLIC e PRIVATE; e
(c) entender o uso de módulos com variáveis públicas e privadas num programa-exemplo.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa17c
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17c/
4) Clicar com o botão do lado direito do mouse sobre o arquivo base.f90
5) Escolher a opção Save Target As
6) Na opção Save in, localizar o diretório do projeto
7) Clicar no botão Save
8) Repetir os itens 4 a 7, acima, para os arquivos base2.f90 e main.f90
9) Comentários sobre o programa:
(a) Dois novos comandos do FORTRAN, associados ao uso de módulos, são usados neste programa:
PUBLIC e PRIVATE.
(b) O comando PRIVATE é empregado para definir uma variável como privativa do módulo no qual
ela é definida. Ou seja, ela só é reconhecida pelas sub-rotinas definidas dentro do próprio
módulo. Ela não é reconhecida como variável dentro de outros módulos ou do programa-
principal que utilizem o módulo no qual ela está definida. Um exemplo é dado na linha
integer,private :: N do módulo PRIMEIRO: a variável N só é reconhecida como tal dentro
17.4 EXERCÍCIOS
Exercício 17.1
(a) Transformar o programa12d.f90 num módulo.
(b) Fazer o mesmo para o programa16c.f90.
(c) Criar um programa-principal para executar as rotinas destes dois módulos.
OBJETIVOS DO CAPÍTULO
• Calcular o resultado de séries infinitas
• Aplicar os métodos de iteração linear, bisseção e Newton para determinar raízes de equações
• Revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot
• Alterar dinamicamente arquivo de comandos do programa de gráficos Wgnuplot e usar novos
comandos
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
18.1 programa18a.f90
1) Objetivos do programa:
(a) exemplificar o cálculo do resultado de séries infinitas;
(b) revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot; e
(c) alterar dinamicamente arquivo de comandos do programa de gráficos Wgnuplot e usar novos
comandos.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome projeto_18
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_18
4) Clicar com o botão do lado direito do mouse sobre o arquivo programa18a.f90
5) Escolher a opção Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no botão OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados18a.txt, comandos18a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte
programa18a.f90, mostrado na Tabela 18.1.
10) Estudar o programa-principal considerando os comentários do item 11, abaixo.
11) Comentários sobre o programa:
(a) O programa18a.f90 é composto pelo programa-principal e seis sub-rotinas.
(b) A sub-rotina DADOS é usada para ler os dados do programa do arquivo dados18a.txt.
∞
1 1 1 ⎛1⎞
S =
2
+
4
+
8
+ K = ∑ ⎜⎝ 2
I =1
I ⎟
⎠
= 1 (18.1)
(d) A sub-rotina SERIE_2 é usada para calcular o valor de π através da soma dos N termos da
seguinte série infinita:
⎛ 1 1 1 1 ⎞ ∞
⎡ (−1) I ⎤
S = 4 ⎜1 − + − + − K⎟ = 4 ∑ ⎢ ⎥ = π (18.2)
⎝ 3 5 7 9 ⎠ I =0 ⎣ ( 2 I + 1) ⎦
(e) A sub-rotina SERIE_3 é usada para calcular o valor do número e através da soma dos N termos
da seguinte série infinita, onde cada termo envolve a sub-rotina FATORIAL:
1 1 1 ∞
⎛1⎞
S = 1 + + + + K = ∑ ⎜⎜ I ! ⎟⎟ = e (18.3)
1! 2! 3! I =0 ⎝ ⎠
(f) As sub-rotinas das três séries também calculam o erro para a solução exata e escrevem no
arquivo saida18a.txt o número e valor de cada termo da série, a soma dos termos e o erro.
(g) A sub-rotina GRAFICO: abre o arquivo comandos18a.gnu; pula as sete primeiras linhas deste
arquivo; na oitava linha, escreve um comentário para representar o título do gráfico de acordo
com a série escolhida para cálculo; na nona linha, escreve outro comentário, que é o comando
replot do Wgnuplot; finalmente, esta sub-rotina executa o programa Wgnuplot para fazer o
gráfico semilog do erro do cálculo da série escolhida, em função do número de termos N usado.
(h) O programa-principal: chama a sub-rotina DADOS; cria o arquivo saida18a.txt; escreve nele um
comentário na primeira linha para indicar o significado de cada coluna de resultados; o símbolo
# é usado para informar ao Wgnuplot que a linha é apenas um comentário, e não dados para o
gráfico; dependendo do tipo de série escolhida pelo usuário é chamada a sub-rotina adequada; o
Notepad abre o arquivo de saída; e, é chamada a sub-rotina para fazer o gráfico do erro.
12) Executar Build, Compile para compilar o programa.
13) Gerar o programa-executável fazendo Build, Build.
14) Executar o programa através de Build, Execute. Usar, os dados mostrados na Figura 18.1.
use portlib
implicit none
integer :: i, n, ver, tipo_serie
real*8 :: soma, exato, erro, termo
call dados
open(6,file="saida18a.txt")
write(6,10)
10 format("# i", t17,"termo", t47,"soma", t77,"erro")
close(6)
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------
subroutine dados
open(5,file="dados18a.txt")
read(5,*) tipo_serie
!-------------------------------------------------
subroutine serie_1
exato = 1
soma = 0
do i = 1, n
termo = 1.0d0 / ( 2.0d0 ** i )
soma = soma + termo
erro = dabs(exato - soma)
write(6,10) i, termo, soma, erro
10 format( i8, 3(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine serie_2
exato = dacos(-1.0d0)
soma = 0
do i = 0, n
termo = 4.0d0 * ((-1)**i) / ( 2.0d0 * i + 1 )
soma = soma + termo
erro = dabs(exato - soma)
write(6,10) i, termo, soma, erro
10 format( i8, 3(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine serie_3
real*8 fatorial_i
exato = dexp(1.0d0)
soma = 0
do i = 0, n
call fatorial ( i, fatorial_i)
termo = 1 / fatorial_i
soma = soma + termo
erro = dabs(exato - soma)
write(6,10) i, termo, soma, erro
10 format( i8, 3(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine fatorial(j,fat)
! calcula o fatorial de j
integer j
real*8 fat, k
fat = 1
do k = 2, j
fat = fat * k
end do
!-------------------------------------------------
integer k
open(9,file="comandos18a.gnu")
do k = 1, 7
read(9,*)
end do
write(9,*) "replot"
close(9)
!-------------------------------------------------
Figura 18.2 Parte do arquivo de resultados do programa18a.f90 para os dados da Fig. 18.1.
Figura 18.3. Gráfico com resultados do programa18a.f90 para os dados da Fig. 18.1.
1) Objetivo do programa: para uma equação quadrática específica, aplicar os métodos de iteração linear,
bisseção e Newton para determinar suas raízes.
2) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte.
b) Edit, Cut para retirar o programa-fonte do projeto.
c) Clicar dentro do campo de edição de programa-fonte.
d) File, Close.
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_18
4) Clicar com o botão do lado direito do mouse sobre o arquivo programa18b.f90
5) Escolher a opção Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no botão OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados18b.txt e comandos18b.gnu
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte programa18b.f90,
mostrado na Tabela 18.2.
10) Estudar o programa-principal considerando os comentários do item 11, abaixo.
11) Comentários sobre o programa:
(a) O programa18b.f90 é composto pelo programa-principal e cinco sub-rotinas.
(b) Para as sub-rotinas DADOS e GRAFICO e o programa-principal valem os mesmos comentários
da seção anterior, exceto que os arquivos envolvidos são agora dados18b.txt, comandos18b.gnu
e saida18b.txt.
(c) As sub-rotinas LINEAR, BISSECAO e NEWTON resolvem a equação
x2 − 5x + 6 = 0 (18.4)
através dos métodos de iteração linear, bisseção e Newton para determinar suas raízes. Detalhes
sobre estes métodos podem ser encontrados na maioria dos livros de cálculo numérico.
12) Executar Build, Compile para compilar o programa.
13) Gerar o programa-executável fazendo Build, Build.
14) Executar o programa através de Build, Execute. Usar, os dados mostrados na Figura 18.4.
15) Analisar os resultados mostrados nas Figuras 18.5 e 18.6.
use portlib
implicit none
integer :: i, n, ver, tipo_metodo
real*8 :: exato, erro, xo, x, r
call dados
x = xo
open(6,file="saida18b.txt")
write(6,10)
10 format("# i", t17,"x", t47,"erro")
erro = dabs(exato - x)
write(6,11) 0, x, erro
11 format( i8, 2(1pe30.15e3) )
close(6)
!-------------------------------------------------
contains
!-------------------------------------------------
subroutine dados
open(5,file="dados18b.txt")
read(5,*) tipo_metodo
read(5,*) n
read(5,*) exato
read(5,*) xo
read(5,*) r
close(5)
!-------------------------------------------------
subroutine linear
do i = 1, n
x = ( ( x ** 2 ) + 6 ) / 5
erro = dabs(exato - x)
write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine bissecao
a = xo - r
b = xo + r
do i = 1, n
fx = x**2 - 5*x + 6
fa = a**2 - 5*a + 6
if ( fx*fa < 0 ) then
b = x
else
a = x
end if
x = (a + b) / 2
erro = dabs(exato - x)
write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine newton
real*8 f, fl
do i = 1, n
f = x**2 - 5*x + 6
fl = 2*x - 5
x = x - f / fl
erro = dabs(exato - x)
write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine grafico
open(9,file="comandos18b.gnu")
do k = 1, 7
read(9,*)
end do
write(9,*) "replot"
close(9)
!-------------------------------------------------
Exercício 18.1
Adaptar o programa18a.f90 para incluir as seguintes opções de séries:
1 1 1 ∞
⎡ 1 ⎤
S = + + + K = ∑ ⎢ I ( I + 1) ⎥ = 1 (18.5)
1x 2 2 x3 3x 4 I =1 ⎣ ⎦
x x2 x3 ∞
⎛ xI ⎞
S = 1 +
1!
+
2!
+
3!
+ K = ∑ ⎜⎜ ⎟⎟ = e x
I =0 ⎝ I ! ⎠
(18.6)
x3 x5 x7 ∞
⎡ (−1) I x 2 I +1 ⎤
S = x −
3!
+
5!
−
7!
+ K = ∑ ⎢
I = 0 ⎣ ( 2 I + 1)! ⎦
⎥ = sen( x) (18.7)
x2 x4 x6 ∞
⎡ (−1) I x 2 I ⎤
S = 1 −
2!
+
4!
−
6!
+ K = ∑ ⎢
I =0 ⎣ ( 2 I ) ! ⎦
⎥ = cos( x) (18.8)
Figura 18.5 Parte do arquivo de resultados do programa18b.f90 para os dados da Fig. 18.4.
Exercício 18.2
Adaptar o programa18a.f90 para usar precisão simples em todos os cálculos com números reais.
Comparar os resultados com a versão original do programa18a.f90 na qual usa-se precisão dupla.
Exercício 18.4
Adaptar o programa18b.f90 para resolver a seguinte equação:
x2 − x − 6 = 0 (18.9)
Figura 18.6 Gráfico com resultados do programa18b.f90 para os dados da Fig. 18.4.
OBJETIVOS DO CAPÍTULO
• Calcular derivadas numéricas com quatro tipos de aproximações numéricas do método de diferenças
finitas: UDS, DDS, CDS-2 e CDS-4.
• Calcular integrais numéricas com três tipos de aproximações numéricas: regras do retângulo, trapézio
e Simpson.
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
19.1 programa19a.f90
1) Objetivo do programa: calcular derivadas numéricas com quatro tipos de aproximações numéricas do
método de diferenças finitas: UDS, DDS, CDS-2 e CDS-4.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome projeto_19
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_19
4) Clicar com o botão do lado direito do mouse sobre o arquivo programa19a.f90
5) Escolher a opção Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no botão OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados19a.txt, comandos19a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte
programa19a.f90, mostrado na Tabela 19.1.
10) Estudar o programa-principal considerando os comentários do item 11, abaixo.
11) Comentários sobre o programa:
(a) O programa19a.f90 é composto pelo programa-principal e quatro sub-rotinas.
(b) A sub-rotina DADOS é usada para ler os dados do programa do arquivo dados19a.txt.
(c) A sub-rotina EXPONENCIAL é usada para calcular a derivada numérica da função f = ex com
quatro tipos de aproximações numéricas do método de diferenças finitas:
⎛ df ⎞ f ( x) − f ( x − h)
⎜ ⎟ ≈ (UDS: um ponto a montante) (19.1)
⎝ dx ⎠ x h
⎛ df ⎞ f ( x + h) − f ( x − h)
⎜ ⎟ ≈ (CDS-2: diferença central de 2 pontos) (19.3)
⎝ dx ⎠ x 2h
onde h = ∆x, intervalo em x usado para aproximar cada derivada. Esta sub-rotina também calcula
o erro de cada uma das quatro aproximações numéricas em relação à solução analítica da
derivada que é ex.
(d) A sub-rotina POTENCIA é usada para calcular a derivada numérica da função f = x5 com os
quatro tipos de aproximações numéricas das Eqs. (19.1) a (19.4). Esta sub-rotina também calcula
o erro de cada uma das quatro aproximações numéricas em relação à solução analítica da
derivada que é 5x4.
(e) A sub-rotina GRAFICO abre o arquivo comandos19a.gnu e desce as primeiras doze linhas deste
arquivo. Na linha seguinte, escreve um comentário para representar o título do gráfico de acordo
com a função escolhida para calcular a derivada. E na linha seguinte, escreve outro comentário,
que é o comando replot do Wgnuplot. Finalmente, esta sub-rotina executa o programa Wgnuplot
para fazer o gráfico log-log do erro do cálculo da derivada da função escolhida, para cada uma
das quatro aproximações numéricas, em função do número de refinos de h definido nos dados do
programa.
(f) O programa-principal: (1) define suas variáveis globais; (2) chama a sub-rotina DADOS; (3) cria
o arquivo saida19a.txt; (4) escreve nele um comentário na primeira linha para indicar o
significado de cada coluna de resultados (o símbolo # é usado para informar ao Wgnuplot que a
linha é apenas um comentário, e não dados para o gráfico); (5) dependendo do tipo de função
escolhida pelo usuário, é chamada a sub-rotina adequada; (6) o Notepad abre o arquivo de saída;
e, (7) é chamada a sub-rotina para fazer o gráfico dos erros com os comandos mostrados na
Figura 19.1.
12) Executar Build, Compile para compilar o programa.
13) Gerar o programa-executável fazendo Build, Build.
14) Executar o programa através de Build, Execute. Usar, os dados mostrados na Figura 19.2.
use portlib
implicit none
open(6,file="saida19a.txt") !
write(6,10)
10 format("#", t5,"h", t20,"E(UDS)", t35,"E(DDS)", t50,"E(CDS-2)", t65,"E(CDS-4)")
close(6)
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------
open(5,file="dados19a.txt")
read(5,*) tipo_funcao
read(5,*) hmax
read(5,*) r
read(5,*) L
read(5,*) X
close(5)
!-------------------------------------------------
subroutine exponencial
real*8 :: xw, h, fp, fw, fl_UDS, fl_DDS, xe, fe, fl_CDS2, &
xww, xee, fww, fee, fl_CDS4
exato = dexp(X)
do i = 0, L
h = hmax / ( r ** i )
xw = X - h
xe = X + h
xww = X - 2*h
xee = X + 2*h
fp = dexp(x)
fw = dexp(xw)
fe = dexp(xe)
fww = dexp(xww)
fee = dexp(xee)
fl_UDS = ( fp - fw ) / h
fl_DDS = ( fe - fp ) / h
fl_CDS2 = ( fe - fw ) / (2 * h)
end do
!-------------------------------------------------
subroutine potencia
real*8 :: xw, h, fp, fw, fl_UDS, fl_DDS, xe, fe, fl_CDS2, &
xww, xee, fww, fee, fl_CDS4
exato = 5*X**4
do i = 0, L
h = hmax / ( r ** i )
xw = X - h
xe = X + h
xww = X - 2*h
xee = X + 2*h
fp = x**5
fw = xw**5
fe = xe**5
fww = xww**5
fee = xee**5
fl_UDS = ( fp - fw ) / h
fl_DDS = ( fe - fp ) / h
fl_CDS2 = ( fe - fw ) / (2 * h)
fl_CDS4 = ( 8*fe - 8*fw + fww - fee ) / (12 * h)
end do
!-------------------------------------------------
subroutine grafico
integer k
open(9,file="comandos19a.gnu")
do k = 1, 12
read(9,*)
end do
write(9,*) "replot"
close(9)
!-------------------------------------------------
15) Analisar os resultados mostrados nas Figuras 19.3 e 19.4. Exceto nos maiores valores de h, as
aproximações UDS e DDS apresentam quase os mesmos valores de erro. Conforme previsto pela
teoria, as aproximações CDS-2 e CDS-4 apresentam os menores valores de erro para um mesmo h.
Teoricamente, o erro de cada aproximação deveria sempre se reduzir com a redução de h, e deveria
19.2 programa19b.f90
1) Objetivo do programa: calcular integrais numéricas com três tipos de aproximações numéricas:
regras do retângulo, trapézio e Simpson.
2) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
a) Clicar sobre o nome do programa-fonte.
b) Edit, Cut para retirar o programa-fonte do projeto.
c) Clicar dentro do campo de edição de programa-fonte.
d) File, Close.
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_19
4) Clicar com o botão do lado direito do mouse sobre o arquivo programa19b.f90
5) Escolher a opção Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no botão OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados19b.txt e comandos19b.gnu
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte programa19b.f90,
mostrado na Tabela 19.2.
10) Estudar o programa-principal considerando os comentários do item 11, abaixo.
use portlib
implicit none
open(6,file="saida19b.txt") !
write(6,10)
10 format("#", t5,"h", t20,"E(retângulo)", t35,"E(trapézio)", t50,"E(simpson)")
close(6)
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------
open(5,file="dados19b.txt")
read(5,*) tipo_funcao
read(5,*) Nmin
read(5,*) r
read(5,*) L
close(5)
!-------------------------------------------------
subroutine exponencial
exato = dexp(1.0d0) - 1
do i = 0, L
h = 1.0d0 / ( Nmin * (r ** i) )
ret = 0.0d0
trap = 0.0d0
do j = 1, Nmin*(r**i)
xp = h*(j-0.5d0)
fp = dexp(xp)
ret = ret + fp * h
xp = h*j
xw = xp - h
fw = dexp(xw)
fp = dexp(xp)
trap = trap + h*(fw+fp)/2
end do
do j = 2, Nmin*(r**i), 2
xp = h*(j-1)
xw = xp - h
xe = xp + h
fw = dexp(xw)
fe = dexp(xe)
fp = dexp(xp)
simp = simp + h*(fw+4*fp+fe)/3
end do
10 format( 4(1pe15.5) )
end do
!-------------------------------------------------
subroutine potencia
exato = 1 / 6.0d0
do i = 0, L
h = 1.0d0 / ( Nmin * (r ** i) )
ret = 0.0d0
trap = 0.0d0
do j = 1, Nmin*(r**i)
xp = h*(j-0.5d0)
xp = h*j
xw = xp - h
fw = xw**5
fp = xp**5
trap = trap + h*(fw+fp)/2
end do
simp = 0.0d0
do j = 2, Nmin*(r**i), 2
xp = h*(j-1)
xw = xp - h
xe = xp + h
fw = xw**5
fe = xe**5
fp = xp**5
simp = simp + h*(fw+4*fp+fe)/3
end do
10 format( 4(1pe15.5) )
end do
!-------------------------------------------------
subroutine grafico
integer k
open(9,file="comandos19b.gnu")
do k = 1, 11
read(9,*)
end do
write(9,*) "replot"
close(9)
!-------------------------------------------------
∑ [ f ( x ) h]
1
∫
0
f dx ≈
k =1
k (regra do retângulo) (19.5)
N
⎡ f ( xk −1 ) + f ( xk ) ⎤
∑ ⎢⎣
1
∫
0
f dx ≈
k =1 2
h⎥
⎦
(regra do trapézio) (19.6)
onde xk = h*k.
N
⎡ f ( xk − 2 ) + 4 f ( xk −1 ) + f ( xk ) ⎤
∑
1
∫
0
f dx ≈ ⎢
k = 2 , 4 ,... ⎣ 3
h⎥
⎦
(regra de Simpson) (19.7)
19.3 EXERCÍCIOS
Exercício 19.1
Acrescentar uma sub-rotina no programa19a.f90 para calcular a derivada de f = 3ex. Incluir a nova opção
de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos quatro tipos de
aproximações e respectivo gráfico.
Figura 19.8. Gráfico com resultados do programa19b.f90 para os dados da Fig. 19.6.
Exercício 19.3
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = 3ex. Incluir a nova opção
de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos três tipos de
aproximações e respectivo gráfico.
Exercício 19.4
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = x4. Incluir a nova opção de
função no arquivo de dados e no programa. Apresentar arquivo com o erro dos três tipos de aproximações
e respectivo gráfico.
OBJETIVOS DO CAPÍTULO
• Aplicar, num único programa, diversos recursos e comandos do FORTRAN vistos nos capítulos
anteriores.
• Resolver sistemas de equações lineares com métodos diretos e iterativos.
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,
através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
20.1 programa20a.f90
AT = B (20.1)
R = B − AT (20.2)
O valor da norma é usado para comparar com uma tolerância especificada pelo usuário visando
interromper o processo iterativo do método de Gauss-Seidel.
(d) O módulo DADOS, contido no programa-fonte dados.f90, tem duas sub-rotinas. Uma é usada
para ler os dados do programa, do arquivo programa20a.ent. A outra é usada para escrever os
dados lidos num arquivo de saída de nome genérico.
(e) O módulo COEFICIENTES, contido no programa-fonte coeficientes.f90, tem duas sub-rotinas.
Uma é usada para definir os valores dos coeficientes da matriz A e do termo independente B do
sistema de equações das N variáveis T. São definidos os valores dos coeficientes apenas em três
diagonais da matriz A. Isso ocorre porque estes coeficientes são originados da discretização de
uma equação diferencial que modela a condução de calor unidimensional em regime
permanente; e a aproximação usada, do método de diferenças finitas, é a diferença central de 2ª
ordem, CDS-2, vista no capítulo 19. O valor de B depende da definição do usuário no arquivo de
dados, gerando valores nulos ou não-nulos. A outra sub-rotina é usada para escrever os valores
dos coeficientes e do termo independente num arquivo de saída de nome genérico.
(f) O módulo RESULTADOS, contido no programa-fonte resultados.f90, também tem duas sub-
rotinas. A primeira é usada para: (1) chamar a sub-rotina de cálculo de coeficientes e termos
independentes; (2) escrever os coeficientes; (3) resolver a Eq. (20.1) com um dos três métodos
use portlib
implicit none
integer :: i ! número do nó
! i = 1, nó no contorno esquerdo
! i = N, nó no contorno direito
! 2 <= i <= N-1, nós internos
end
use variaveis
contains
!-------------------------------------------------
subroutine EG (N,ap,b,c,d,T)
implicit none
integer :: i ! número do nó
integer :: ii, j
real*8 :: mji, S
real*8,intent(out),dimension(N) :: T ! incógnita
allocate ( A(N,N+1) )
A = 0.0d0
do i = 1,N
A(i,i) = ap(i)
A(i,N+1) = d(i)
! Escalonamento
do i = 1,N-1
do ii = i+1,N
do j = i,N+1
end do
end do
end do
!Substituicao retroativa
do i = N-1,1,-1
S = 0
do j = i+1,N
S = S + A(i,j)*T(j)
end do
end do
deallocate ( A )
end subroutine EG
subroutine GS (N,ite,tol,a,b,c,d,T)
implicit none
integer :: i ! número do nó
integer :: it ! número da iteração
integer :: ite ! número de iterações
real*8,intent(out),dimension(N) :: T ! incógnita
T = 0.0d0
do it = 1, ite
do i = 2, N-1
end do
end do
end subroutine GS
!-------------------------------------------------
implicit none
integer :: i ! número do nó
real*8,intent(out),dimension(N) :: T ! incógnita
R = 0.0d0
do i = 2, N-1
end do
R = R / N
!-------------------------------------------------
implicit none
integer :: i ! número do nó
real*8 :: div ! variável auxiliar
real*8,intent(out),dimension(N) :: T ! incógnita
allocate(P(N),Q(N))
do i = 2, N
div = a(i) - b(i)*P(i-1)
P(i) = c(i) / div
Q(i) = (d(i) + b(i)*Q(i-1))/div
T(N) = Q(N)
do i = N-1, 1, -1
T(i) = P(i)*T(i+1) + Q(i)
end do
deallocate(P,Q)
!-------------------------------------------------
use variaveis
!-------------------------------------------------
implicit none
contains
!-------------------------------------------------
subroutine le_dados
open(7,file='programa20a.ent')
read(7,*) caso
read(7,*) N
read(7,*) matriz
read(7,*) solver
read(7,*) iteracao
close(7)
!-------------------------------------------------
subroutine mostra_dados
integer :: comp
comp = len(trim(adjustl(caso)))
1 format(/,5x,'DADOS',//, &
a<comp>,' = caso',/, &
i6,' = número de nós',/, &
i6,' = tipo de matriz: 1 = fonte nulo; 2 = fonte não-nulo',/, &
i6,' = tipo de solver: 1=El.Gauss; 2=GS; 3=TDMA',/, &
i6,' = número de iterações para o GS',/, &
1pe10.2,' = tolerância sobre o resíduo para o GS')
!-------------------------------------------------
use dados
implicit none
!-------------------------------------------------
subroutine lista_coeficientes
write(10,4)
4 format(/,5x,'COEFICIENTES E FONTES',//, &
t6,'nó',t16,'X',t36,'oeste',t56,'central', &
t76,'leste',t96,'fonte',/)
do i = 1, N
if ( i==1 .or. i==n .or. mod(i,w)==0 ) &
write(10,2) i, X(i), aw(i), aP(i), ae(i), bP(i)
end do
2 format(i6,4x,5(1pe20.9))
!-------------------------------------------------
subroutine coeficientes_e_fontes
! volumes internos
do i = 2, N-1
aw(i) = 1.0d0
ae(i) = 1.0d0
aP(i) = aw(i) + ae(i)
end do
! contorno esquerdo
aw(1) = 0.0d0
ae(1) = 0.0d0
aP(1) = 1.0d0
bP(1) = 0.0d0
!-------------------------------------------------
!-------------------------------------------------
use coeficientes
use solvers_1D
implicit none
contains
! -----------------------------------------------
subroutine solucao_numerica
call EG (N,aP,aw,ae,bP,T)
case ( 2 ) ! Gauss-Seidel
call GS (N,iteracao,Tol,aP,aw,ae,bP,T)
case ( 3 ) ! TDMA
end select
tcpu = timef()
write(10,1) tcpu
1 format(/, f14.3, ' = tempo de processamento (segundos)')
!-------------------------------------------------
subroutine escreve_T
write(10,1)
1 format(/,t4,'X',t28,'T (analítico)',t52,'T (numérico)',t76,'erro',/)
do i = 1, N
end do
close(7)
! mostra o gráfico de T
ver = system('wgnuplot comandos20a.gnu')
!-------------------------------------------------
program programa20a
! -----------------------------------------------
use resultados
! -----------------------------------------------
implicit none
integer :: comp
!-------------------------------------------------
call date_and_time(vardate,vartime,varzone,var)
write(aux,*) var(3)
aux1 = trim(adjustl(aux))
write(aux,*) var(2)
aux2 = trim(adjustl(aux))
write(aux,*) var(1)
aux3 = trim(adjustl(aux))
dia = '('//trim(aux1)//'/'//trim(aux2)//'/'//aux3//')'
write(aux,*) var(5)
aux1 = trim(adjustl(aux))
write(aux,*) var(6)
aux2 = trim(adjustl(aux))
write(aux,*) var(7)
aux3 = trim(adjustl(aux))
hora = trim(aux1)//':'//trim(aux2)//':'//aux3
call le_dados
open(10,file=caso)
comp = len(trim(adjustl(title)))
do i = 1, N
X(i) = (i-1.0d0) / (N-1)
end do
call mostra_dados
call solucao_numerica
close (10)
! -----------------------------------------------
End
13) Executar Build, Compile para compilar o programa-fonte variaveis.f90. Em seguida, executar
Build, Compile para compilar os demais programas-fonte na seguinte ordem: solvers_1D.f90,
dados.f90, coeficientes.f90, resultados.f90 e programa20a.f90.
14) Gerar o programa-executável fazendo Build, Build.
15) Executar o programa através de Build, Execute. Usar os dados mostrados na Figura 20.2.
16) Analisar os resultados mostrados nas Figuras 20.3 e 20.4. O erro apresentado pela solução na
Figura 20.4 deve-se aos erros de arredondamento.
17) Executar novamente o programa usando os mesmos dados da Figura 20.2, exceto, matriz = 1 e
analisar os novos resultados.
Figura 20.3. Gráfico com resultados do programa20a.f90 para os dados da Fig. 20.2.
20.2 EXERCÍCIOS
Exercício 20.2
Executar novamente o programa20a.f90 usando os mesmos dados da Figura 20.2, exceto, matriz = 2 e
solver = 2. Por tentativa e erro, usar um valor para a variável “iteracao” que seja suficiente para satisfazer
a tolerância (Tol) estipulada na Figura 20.2. Comparar o tempo de CPU resultante neste caso, para o
método de Gauss-Seidel, àquele do método TDMA (item 19) e do método de Eliminação de Gauss (item
16).
Para criar um projeto do tipo Console Application, devem ser executados os seguintes passos:
1) No menu do Fortran: File, New.
2) Na janela New, clicar sobre a opção Project Workspace. Depois, clicar sobre o botão OK.
3) Na janela New Project Workspace, é necessário executar o que segue:
a) Entre os seis tipos de projetos apresentados na opção Type, clicar sobre Console Application no
caso deste tipo de projeto não estar selecionado (realçado em azul).
b) Na opção Location estará indicado um diretório (pasta) default, ou seja, um diretório escolhido
pelo próprio Fortran em função de sua configuração atual. É possível que não seja o diretório
desejado. Neste caso, deve-se clicar sobre o botão Browse para indicar o diretório onde se quer
criar o projeto. Ao se fazer isso, surgirá a janela Choose Directory na qual deve-se executar:
· Na opção Drives, escolher Z:\\SERVER1\Alunos2004_1
· Na opção Directory name, clicar duas vezes sobre o nome do diretório que é idêntico ao
user name usado para acessar a rede Windows do DEMEC/UFPR
· Clicar sobre o botão OK.
c) Estará de volta a janela New Project Workspace. Clicar dentro do espaço de edição da opção
Name. Escrever o nome do projeto. Deve-se perceber que o nome do projeto, digitado na opção
Name, aparece automaticamente na opção Location. Em seguida, deve-se clicar sobre o botão
Create. Após isso, o Fortran criará um diretório com o nome do projeto indicado, dentro do
diretório já selecionado.
ADAMS, J. C.; BRAINERD, W. S.; MARTIN, J. T.; SMITH, B. T.; WAGENER, J. L. FORTRAN 95
Handbook; Complete ISO/ANSI Reference. London : MIT Press, 1997.
HAHN, B. Fortran 90 for Scientists and Engineers. New York : Chapman & Hall, 1994.
Referências bibliográficas 1