Fortran90 Index

FORTRAN 90
PARA
WINDOWS
Sumrio
Captulo 1. INTRODUO ................................................................................................................................................. 7
OBJETIVOS DO CAPTULO ............................................................................................................................................. 7
1.1 USO DESTE TEXTO EM DISCIPLINAS .................................................................................................................... 7
1.2 BIBLIOGRAFIA ..................................................................................................................................................... 7
1.3 FORTRAN............................................................................................................................................................. 8
1.4 CONVENES...................................................................................................................................................... 8
1.5 INICIALIZAO DO APLICATIVO FORTRAN POWERSTATION 4.0 ........................................................................ 9
1.6 CRIAO DE UM PROJETO DO TIPO CONSOLE APPLICATION .......................................................................... 11
1.7 CRIAO E INSERO DO PROGRAMA-FONTE DENTRO DO PROJETO ............................................................ 14
1.8 EDIO DO PROGRAMA-FONTE ....................................................................................................................... 17
1.9 COMPILAO E GERAO DO PROGRAMA-OBJETO ........................................................................................ 18
1.10 GERAO DO PROGRAMA-EXECUTVEL ........................................................................................................ 20
1.11 EXECUO DO PROGRAMA ............................................................................................................................ 21
1.12 FIM DA SESSO ............................................................................................................................................... 22
1.13 EXERCIOS ....................................................................................................................................................... 23
Captulo 2. VARIVEIS DO TIPO INTEIRO ........................................................................................................................ 24
OBJETIVOS DO CAPTULO ........................................................................................................................................... 24
2.1 programa02.f90, verso A ................................................................................................................................ 24
2.2 programa02.f90, verso B ................................................................................................................................ 26
2.3 programa02.f90, verso C ................................................................................................................................ 27
2.4 programa02.f90, verso D ................................................................................................................................ 28
2.5 programa02.f90, verso E................................................................................................................................. 29
2.6 programa03.f90, verso A ................................................................................................................................ 30
2.7 programa03.f90, verso B ................................................................................................................................ 33
2.8 FIM DA SESSO ................................................................................................................................................. 35
2.9 EXERCIOS ......................................................................................................................................................... 35
Captulo 3. VARIVEIS DO TIPO REAL ............................................................................................................................. 37

2
3.1 programa03c.f90 .............................................................................................................................................. 37
3.2 programa03d.f90 .............................................................................................................................................. 40
3.3 programa03e.f90 .............................................................................................................................................. 41
3.4 ESCALA DE PRIORIDADES ENTRE OS OPERADORES MATEMTICOS ................................................................ 43
3.5 programa03f.f90 ............................................................................................................................................... 45
3.6 EXERCCIOS ....................................................................................................................................................... 48
Captulo 4. VARIVEIS DO TIPO CARACTER .................................................................................................................... 50
4.1 programa4a.f90 ................................................................................................................................................ 50
4.2 programa4b.f90 ................................................................................................................................................ 53
4.3 programa4c.f90 ................................................................................................................................................ 54
4.4 programa4d.f90 ................................................................................................................................................ 56
4.5 EXERCCIO ......................................................................................................................................................... 54
Captulo 5. ARQUIVOS E FUNES MATEMTICAS INTRNSECAS ................................................................................. 55
5.1 programa5a.f90 ................................................................................................................................................ 55
5.2 programa5b.f90 ................................................................................................................................................ 57
5.3 programa5c.f90 ................................................................................................................................................ 60
5.4 programa5d.f90 ................................................................................................................................................ 62
5.5 EXERCCIOS ....................................................................................................................................................... 66
Captulo 6. FORMATOS DE EDIO ................................................................................................................................ 68
6.1 FORMATOS DE EDIO PARA VARIVEIS DO TIPO CARACTER: programa6a.f90............................................. 68
6.2 FORMATOS DE EDIO PARA VARIVEIS DO TIPO INTEIRO: programa6b.f90 ................................................ 73
6.3 FORMATOS DE EDIO PARA VARIVEIS DO TIPO REAL: programa6c.f90 ...................................................... 76
6.4 RESUMO DE REGRAS GERAIS DE EDIO DE PROGRAMAS EM FORTRAN ....................................................... 80
6.5 SEQNCIA OBRIGATRIA DE COMANDOS EM FORTRAN............................................................................... 81
6.6 EXERCCIOS ....................................................................................................................................................... 81
Captulo 7. DECISES E OPES ..................................................................................................................................... 83

3
7.1 programa7a.f90 ................................................................................................................................................ 83
7.2 programa7b.f90 ................................................................................................................................................ 86
7.3 programa7c.f90 ................................................................................................................................................ 89
7.4 EXERCCIOS ....................................................................................................................................................... 92
Captulo 8. CICLOS .......................................................................................................................................................... 94
OBJETIVOS DO CAPTULO ....................................................................................................................................... 94
8.1 programa8a.f90 ................................................................................................................................................ 94
8.2 programa8b.f90 ................................................................................................................................................ 95
8.3 programa8c.f90 ................................................................................................................................................ 99
8.4 EXERCCIOS ..................................................................................................................................................... 102
Captulo 9. CONJUNTOS................................................................................................................................................ 104
OBJETIVOS DO CAPTULO ......................................................................................................................................... 104
9.1 programa9a.f90 .............................................................................................................................................. 104
9.2 programa9b.f90 .............................................................................................................................................. 108
9.3 programa9c.f90 .............................................................................................................................................. 110
9.4 programa9d.f90 .............................................................................................................................................. 113
9.5 EXERCCIOS ..................................................................................................................................................... 115
Captulo 10. MATRIZES ................................................................................................................................................. 117
10.1 programa10a.f90 .......................................................................................................................................... 117
10.2 programa10b.f90 .......................................................................................................................................... 122
10.3 EXERCCIOS ................................................................................................................................................... 128
Captulo 11. GRFICOS COM WGNUPLOT .................................................................................................................... 130
11.1 INSERO DO APLICATIVO WGNUPLOT NUM PROJETO .............................................................................. 130
11.2 UTILIZAO BSICA DO WGNUPLOT ............................................................................................................ 130
11.3 UTILIZAO DO WGNUPLOT PARA FAZER GRFICO DE UM ARQUIVO DE DADOS ...................................... 133
11.4 UTILIZAO DO WGNUPLOT COM ARQUIVO DE COMANDOS ..................................................................... 136
11.5 programa11.f90 ............................................................................................................................................ 137

4
11.6 EXERCCIOS ................................................................................................................................................... 140
Captulo 12. SUB-ROTINAS............................................................................................................................................ 141
12.1 programa12a ................................................................................................................................................ 141
12.2 programa12b ................................................................................................................................................ 145
12.3 programa12c................................................................................................................................................. 148
12.4 programa12d ................................................................................................................................................ 150
12.5 EXERCCIO ..................................................................................................................................................... 153
Captulo 13. VARIVEIS DO TIPO REAL DUPLA ............................................................................................................. 154
13.1 programa13a.f90 .......................................................................................................................................... 154
13.3 programa13c.f90 .......................................................................................................................................... 158
13.4 programa13d.f90 .......................................................................................................................................... 160
13.5 EXERCCIOS ................................................................................................................................................... 163
Captulo 14. ARQUIVOS DE SADA, DE ENTRADA E INTERNOS ..................................................................................... 165
14.1 programa14a.f90 .......................................................................................................................................... 165
14.2 programa14b.f90 .......................................................................................................................................... 166
14.3 programa14c.f90 .......................................................................................................................................... 169
14.4 programa14d.f90 .......................................................................................................................................... 170
14.5 programa14e.f90 .......................................................................................................................................... 174
14.6 EXERCCIOS ................................................................................................................................................... 176
Captulo 15. INICIALIZAO, TEMPO DE CPU E DOS .................................................................................................... 178
15.1 programa15a.f90 .......................................................................................................................................... 178
15.2 programa15b.f90 .......................................................................................................................................... 180
15.3 programa15c.f90 .......................................................................................................................................... 185
15.4 EXERCCIOS ................................................................................................................................................... 189
Captulo 16. MEMRIA E SUB-ROTINAS 2 .................................................................................................................... 191

5
16.1 programa16a.f90 .......................................................................................................................................... 191
16.2 programa16b.f90 .......................................................................................................................................... 197
16.3 programa16c.f90 .......................................................................................................................................... 199
16.4 EXERCCIOS ................................................................................................................................................... 204
Captulo 17. MDULOS................................................................................................................................................. 206
OBJETIVOS DO CAPTULO ..................................................................................................................................... 206
17.1 programa17a.f90 .......................................................................................................................................... 206
17.2 programa17b.f90 .......................................................................................................................................... 209
17.3 programa17c.f90 .......................................................................................................................................... 212
17.4 EXERCCIOS ................................................................................................................................................... 213
Captulo 18. SOLUO DE SRIES E RAZES DE EQUAES .......................................................................................... 212
18.1 programa18a.f90 .......................................................................................................................................... 212
18.2 programa18b.f90 .......................................................................................................................................... 218
18.3 EXERCCIOS ................................................................................................................................................... 223
Captulo 19. DERIVADAS E INTEGRAIS NUMRICAS ..................................................................................................... 226
19.2 programa19b.f90 .......................................................................................................................................... 234
19.3 EXERCCIOS ................................................................................................................................................... 241
Captulo 20. SOLUO DE SISTEMAS DE EQUAES.................................................................................................... 243
20.1 programa20a.f90 .......................................................................................................................................... 243
20.2 EXERCCIOS ....................................................................................................................................................... 261
Procedimento: CRIAR PROJETO DO TIPO CONSOLE APPLICATION............................................................................... 264
Procedimento: FIM DE SESSO .................................................................................................................................... 265
REFERNCIAS BIBLIOGRFICAS..................................................................................................................................... 266
6
Captulo 1. INTRODUO
OBJETIVOS DO CAPTULO
Conceitos de: linguagem de programao, FORTRAN, projeto, programa-fonte, programa-objeto,
programa-executvel, compilao, comando
Procedimentos bsicos para programar em linguagem FORTRAN
Comandos do FORTRAN: WRITE e END
1.1 USO DESTE TEXTO EM DISCIPLINAS
O objetivo deste texto ensinar a implementar programas com a linguagem FORTRAN 95 e,

implicitamente, a desenvolver algoritmos para resolver problemas bsicos de matemtica e fsica. Os
captulos 1 a 13 deste texto so recomendados para disciplinas introdutrias de programao em cursos de
engenharia. J os captulos 14 a 20 podem ser usados em cursos avanados de programao em nvel de
graduao.
Cada captulo foi estruturado para ser lecionado em aulas com durao de duas horas. Uma
disciplina de 30 horas vem sendo ministrada no primeiro perodo semestral do curso de graduao em
engenharia mecnica da Universidade Federal do Paran. Esta disciplina envolve os captulos 1 a 13 mais
duas provas. Outra disciplina, envolvendo os captulos 1 a 20, com 45 horas, est prevista para ser
lecionada em nvel de ps-graduao.
1.2 BIBLIOGRAFIA
No 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
referncia para termos tcnicos de informtica em portugus. Dois textos recomendados sobre algoritmos
so 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 organizaes ISO (International Standadrs Organization) e ANSI
(American National Standards Institute).
7
1.3 FORTRAN
Existe uma infinidade de linguagens de programao, por exemplo, Assembly, Cobol, Visual
Basic, Pascal, Java, C++ etc (Ramalho, 2000, p. 114 e 124-30). Elas so usadas para criar os programas,
tambm denominados de softwares ou aplicativos, que so empregados nos computadores. A utilidade
das linguagens de programao pode ser percebida ao se lembrar para que so 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
automticos dos bancos.
A linguagem FORTRAN, contrao de FORmula TRANslation (Traduo de Frmulas), ainda a
principal linguagem de programao usada em engenharia e aplicaes cientficas (Adams, 2000, p. 1).
Foi criada em 1954. Sua primeira verso comercial surgiu em 1957. As verses do FORTRAN
padronizadas pela ANSI e ISO so:
1) Ano 1966 = FORTRAN 66
1.4 CONVENES
Para melhor entendimento deste texto, as seguintes convenes so adotadas:

1) So mostrados na cor azul links para endereos de sites da internet ou para arquivos que definem
termos e procedimentos importantes para este texto.
2) Comandos de programas ou aplicativos que devem ser executados ao longo do texto so
mostrados em negrito. A vrgula usada para separar uma seqncia de comandos.
3) So apresentados na cor vermelha: os programas, seus dados (entradas) e seus
resultados (sadas).
4) Qualquer referncia ao sistema operacional Windows NT 4.0 abreviado para Windows.
5) Qualquer referncia ao aplicativo Fortran PowerStation 4.0, da Microsoft, abreviado para Fortran.
6) Qualquer referncia linguagem FORTRAN abreviado para FORTRAN, tudo em maisculo para
distinguir do aplicativo Fortran PowerStation 4.0.
7) Devido grande quantidade de termos em ingls, no feito qualquer distino para palavras em
portugus.
8) Comandos, isto , palavras-chave da linguagem FORTRAN so apresentados em letras maisculas.
8
1.5 INICIALIZAO DO APLICATIVO FORTRAN POWERSTATION 4.0
Para seguir este texto, no necessrio nenhum conhecimento anterior sobre linguagem de
programao. necessrio apenas ter conhecimentos bsicos sobre o sistema operacional Windows NT
4.0 ou verses mais recentes. Todos os programas em FORTRAN apresentados neste texto foram
editados e compilados com o aplicativo Fortran PowerStation 4.0, da Microsoft. Alm de seus manuais,
este aplicativo contm o livro de Hahn (1994) sobre FORTRAN 90 e o item Reference onde so 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
edio 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.
Figura 1.1 Inicializao do aplicativo Fortran PowerStation 4.0.
Na janela principal do Fortran, mostrada na Figura 1.2, pode-se perceber:
9
Figura 1.2 Janela principal do aplicativo Fortran PowerStation 4.0.
1) Na barra em azul, o cone do Fortran e o ttulo da janela principal: Microsoft Developer Studio.
2) Abaixo da barra em azul, o menu do Fortran, ou seja, as opes existentes para usar este aplicativo,
que so: File, Edit, View, Insert, Build, Tools, Window e Help.
3) A janela principal do Fortran dividida em trs partes ou subjanelas. Se no estiver aparecendo a
subjanela inferior, mostrada na Figura 1.2, deve-se executar: View, Output.
4) Na subjanela do lado esquerdo, tem-se o diretrio principal dos manuais do Fortran, destacando-se:
Reference, que uma lista de comandos do FORTRAN 90, incluindo explicaes e exemplos de uso;
e Fortran 90 for Scientists and Engineers, que um livro sobre a linguagem FORTRAN 90. Esta
subjanela tambm 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 opo ?
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 opo FileView.
5) Na subjanela inferior so apresentadas informaes sobre erros de programao e compilao.
Detalhes sero vistos no captulo 2.
6) A subjanela do lado direito, a maior das trs, usada para: apresentar o contedo dos manuais e para a
edio de programas em FORTRAN.
1
1.6 CRIAO DE UM PROJETO DO TIPO CONSOLE APPLICATION
O Fortran organiza todos os arquivos de um programa numa entidade chamada projeto. Em termos
prticos, a criao de um projeto resulta na criao de uma pasta ou diretrio 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 bsica, que compreende os captulos 1 a 13, so empregados apenas projetos do tipo Console
Application. E na parte avanada, que corresponde aos captulos 14 a 20, so 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.
Figura 1.3 Incio da criao de um projeto no Fortran.
2) Na janela New, mostrada na Figura 1.4, clicar sobre a opo Project Workspace. Depois, clicar
sobre o boto OK.
3) Na janela New Project Workspace, mostrada na Figura 1.5, necessrio executar o que segue:
1
Figura 1.4 Segundo passo na criao de um projeto no Fortran.
Figura 1.5 Janela para definio do tipo, diretrio e nome do projeto.
a) Entre os seis tipos de projetos apresentados na opo Type, clicar sobre Console Application no
caso deste tipo de projeto no estar selecionado (realado em azul).
b) Na opo Location estar indicado um diretrio (pasta) default, ou seja, um diretrio escolhido
pelo prprio Fortran em funo de sua configurao atual. possvel que no seja o diretrio
desejado. Neste caso, deve-se clicar sobre o boto Browse para indicar o diretrio 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 opo Drives, clicando sobre o tringulo invertido, escolher C:
Na opo Directory name, digitar C:\MSDEV\Projects, conforme mostrado na Figura 1.7.
Clicar sobre o boto OK.
c) Estar de volta a janela New Project Workspace, mostrada na Figura 1.5. Clicar dentro do espao
de edio da opo 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 opo Name, aparece automaticamente na opo Location. Em
1
seguida, deve-se clicar sobre o boto Create. Aps isso, o Fortran criar um diretrio com o nome
do projeto indicado, dentro do diretrio j selecionado, conforme mostrado na Figura 1.9.
Figura 1.6 Definio do drive do projeto.
Figura 1.7 Definio do diretrio para criao do projeto.
Figura 1.8 Tipo, nome e diretrio do projeto j definidos.
1
Figura 1.9 Fortran com o nome do diretrio criado para o projeto especificado.
1.7 CRIAO E INSERO DO PROGRAMA-FONTE DENTRO DO PROJETO
O processo de edio ou criao de um programa semelhante redao de uma carta com o

aplicativo Word, que um editor de textos. So necessrios dois componentes: um editor de textos para
escrever o programa computacional e um arquivo para guardar o texto no hard disk (HD) do computador.
No caso dos programas computacionais, a carta chamada de programa-fonte e pode ser aberta, editada
ou redigida dentro do Fortran ou em qualquer outro editor de textos. Ao longo deste texto, as palavras
edio, digitao e implementao sero usadas como sinnimos. Para iniciar a edio ou escrita de um
programa-fonte em linguagem FORTRAN necessrio criar e inserir um arquivo dentro do projeto. Isso
feito atravs dos seguintes passos:
1) No menu do Fortran, conforme mostrado na Figura 1.10, executar: Insert, Files into Project
2) Na janela Insert Files into Project, mostrada na Figura 1.11, executar o seguinte:
a) Na opo File Name, digitar o nome do programa-fonte a ser criado; por exemplo, como mostrado
na Figura 1.12, programa01.f90
Sempre deve-se usar f90 como extenso dos nomes dos arquivos do tipo programa-fonte. Ele
indica que o programa est ou ser escrito na linguagem FORTRAN 90 ou 95.
Captulo 1. Introduo 14
b) Clicar sobre o boto OK
Figura 1.10 Incio da criao do programa-fonte.
Figura 1.11 Janela para definio do nome do programa-fonte a inserir no projeto.
3) Na janela Microsoft Developer Studio, mostrada na Figura 1.13, clicar sobre o boto 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
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 boto 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.12 Nome do programa-fonte j definido.
Figura 1.13.
Figura 1.14.
Figura 1.15 Fortran pronto para edio do programa-fonte.
1.8 EDIO DO PROGRAMA-FONTE
Aps a criao e insero do programa-fonte dentro do projeto, o Fortran est pronto para ser
usado na edio do programa-fonte, conforme mostrado na Figura 1.15. Um exemplo de edio de
programa-fonte apresentado a seguir.
1) Dentro do espao de edio 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 espao em branco).
WRITE(*,*) "Meu primeiro programa em FORTRAN"

WRITE(*,*) "Ano 2004"
END
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 diretrio e o
nome do programa-fonte que foi gravado ou salvo, como mostrado na Figura 1.16.
3) Comentrios sobre este programa:
a) Dentro do editor de textos do Fortran, os comandos da linguagem FORTRAN so 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 so palavras-chave que tm uma funo especfica 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, so usados apenas dois comandos: WRITE e END.
c) Como ser visto aps a execuo 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 aps o comando
WRITE(*,*) escrito numa janela.
d) O comando END necessrio para indicar o fim do programa.
Figura 1.16 Programa-fonte escrito na linguagem FORTRAN.
1.9 COMPILAO E GERAO DO PROGRAMA-OBJETO
Aps concluir a edio de um programa-fonte, ele deve ser compilado. O processo de compilao
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 binrio
(escrito na linguagem dos computadores, usando apenas os algarismos zero-0 e um-1). Uma linguagem de
programao de alto nvel (Ramalho, 2000) como o FORTRAN se constitui numa forma amigvel ou
relativamente fcil de se escrever programas. O aplicativo Fortran PowerStation 4.0, alm do editor de
programas, tambm 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
Aps a compilao, conforme mostrado na Figura 1.17, aparecero trs 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 diretrio 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 nmero de erros (errors) e de avisos (warnings) relativos ao programa-fonte compilado. Se houver
algum erro, o programa-objeto no gerado. Avisos no impedem a gerao do programa-objeto. O
nome do programa-objeto igual ao nome do programa-fonte mas com extenso obj
Figura 1.17 Compilao do programa-fonte.
A compilao cria automaticamente um subdiretrio chamado Debug dentro do diretrio do

projeto. Dentro deste subdiretrio que se encontra o programa-objeto bem como outros arquivos
auxiliares. Pode-se ver isso com o aplicativo Windows NT Explorer, que acessado executando o
seguinte no Windows: Start, Programs, Windows NT Explorer. Depois, deve-se acessar o diretrio do
projeto, que deve estar dentro do diretrio C:\Msdev\Projects
1.10 GERAO DO PROGRAMA-EXECUTVEL
Aps o processo de compilao, necessrio gerar o programa-executvel, que um arquivo

possvel de ser executado ou rodado pelo computador, como qualquer outro programa ou aplicativo;
por exemplo, os aplicativos Word, Excel, PowerPoint, FrontPage, CorelDraw, Acrobat, e o navegador
Internet Explorer. O programa-executvel resulta da unio do programa-objeto, que foi gerado na
compilao do programa-fonte, com outros programas-objeto da prpria linguagem FORTRAN, que
contm a traduo dos comandos do FORTRAN, como o WRITE e END usados no primeiro programa-
fonte (Figura 1.17).
Para gerar o programa-executvel, deve-se fazer o seguinte no menu do Fortran: Build, Build. Em
seguida, conforme mostrado na Figura 1.18, aparecero duas linhas com mensagens na subjanela da
parte inferior do Fortran:
Figura 1.18 Gerao do programa-executvel.
1) A primeira informa que o Fortran est gerando o programa-executvel, processo chamado de
lincagem (linking).
2) A segunda informa o nome do programa-executvel (no caso, programa01.exe) que foi gerado e o
nmero de erros (errors) e de avisos (warnings) relacionados a ele. O nome do programa-executvel
igual ao nome do projeto mas com extenso exe
O programa-executvel gravado automaticamente dentro do subdiretrio Debug, que fica dentro
do diretrio do projeto, alm 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 extenso
ou Type do programa-executvel aparece como Application.
Figura 1.19 Diretrio do projeto programa01 e seu subdiretrio Debug.
1.11 EXECUO DO PROGRAMA
Aps gerar o programa-executvel, para execut-lo ou rod-lo, isto , para coloc-lo em

funcionamento, basta fazer o seguinte no menu do Fortran: Build, Execute. Como resultado deste
comando, deve ocorrer o seguinte:
1) Aparecer uma janela do tipo DOS, conforme a Figura 1.20. Isso ocorre porque na seo 1.6 foi criado
um projeto do tipo Console Application.
2) No ttulo desta janela, com fundo em azul, aparece o nome do programa que est sendo executado e o
diretrio 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 execuo 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) Alm disso, tambm aparece a frase Press any key to continue. Como diz este aviso, basta clicar em
qualquer tecla para continuar. Ao fazer isso, a execuo do programa encerrada.
Figura 1.20 Resultado da execuo do programa01.
1.12 FIM DA SESSO
Para concluir o uso do Fortran e do Windows, deve-se executar o seguinte:

1) Para encerrar as atividades com um projeto, basta executar no menu do Fortran: File, Close
Workspace
2) Na janela Microsoft Developer Studio, clicar sobre o boto Yes
3) Para fechar o aplicativo Fortran, basta fazer o seguinte em seu menu: File, Exit
4) Para fechar o Windows, executar: Start, Shut Down
5) Na janela Shut Down Windows, escolher a opo Close all programs and log on as a different
user?. Clicar sobre o boto Yes
1.13 EXERCIOS
Exerccio 1.1
1) Editar um programa-fonte em FORTRAN para escrever a data atual.
2) Compilar o programa-fonte
3) Gerar o programa-executvel
4) Executar o programa
Exerccio 1.2
1) Repetir o exerccio 1.1 para escrever em linhas diferentes cada um dos seguintes itens: nome, e-mail,
endereo e telefone de uma pessoa.
Captulo 2. VARIVEIS DO TIPO INTEIRO
Conceitos de: variveis do tipo inteiro, atribuio, avisos e erros de compilao, erros de execuo,
comentrios dentro do programa-fonte
Operadores matemticos bsicos
Comandos do FORTRAN: INTEGER e READ
2.1 programa02.f90, verso A
Para inicializar as atividades deste captulo, deve-se executar:

1) No Windows, seguindo o procedimento apresentado na seo 1.5 do captulo 1: Start, Programs,
Fortran PowerStation 4.0, Microsoft Developer Studio
2) No Fortran, seguindo o procedimento apresentado na seo 1.6 do captulo 1, criar um projeto do tipo
Console Application com o nome programa02 no diretrio Z:\\SERVER1\Alunos2004_1\login,
onde login deve ser substitudo pelo user name do usurio, isto , a conta particular na rede Windows
do DEMEC/UFPR.
3) No Fortran, seguindo o procedimento apresentado na seo 1.7 do captulo 1, criar e inserir no projeto
o programa-fonte programa02.f90
4) Conforme mostrado na Figura 2.1, dentro do espao de edio do Fortran, na subjanela maior,
copiar exatamente o texto mostrado abaixo em vermelho.
INTEGER A
WRITE(*,*) "A"
WRITE(*,*) A
END
5) Comentrios sobre o programa:

a) No captulo 1 foram usados os comandos WRITE e END da linguagem FORTRAN. No
programa02.f90, h um novo comando: INTEGER. Ele usado para definir variveis do tipo
inteiro, isto , variveis que podem guardar ou armazenar na memria do computador nmeros
inteiros, positivos ou negativos, como 2, 5, 0, 54367 ou 3.
b) A linha INTEGER A define a varivel A como sendo do tipo inteiro. Este comando reserva um
espao na memria do computador, utilizando o nome ou rtulo A para armazenar um valor
Captulo 2. Variveis do tipo inteiro 24
inteiro.
c) A linha WRITE(*,*) "A" escreve o comentrio que est entre aspas; no caso a letra A.
d) A linha WRITE(*,*) A escreve o valor da varivel A que est armazenado na memria do
computador.
e) A linha END encerra o programa.
6) Ao se compilar o programa, executando Build, Compile, o resultado deve ser o mostrado na Figura
2.1. Deve-se notar na subjanela inferior um aviso (warning) mencionando que o valor da varivel A
no foi definido.
7) Gerar o programa-executvel fazendo Build, Build.
Figura 2.1 Resultado da compilao do programa02.f90, verso A.
8) Ao se executar o programa, atravs 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 no foi definido um valor para a varivel A, conforme o prprio Fortran informou durante
a compilao do programa. Portanto, sempre necessrio definir o valor de cada varivel do
programa, caso contrrio, 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 execuo do programa encerrada.
9) Deve-se perceber a diferena que existe entre os comandos WRITE(*,*) "A" e WRITE(*,*) A do
programa. No primeiro, A um comentrio. No segundo, A uma varivel utilizada para armazenar
um valor inteiro na memria do computador.

Figura 2.2 Resultado da execuo do programa02.f90, verso A.
2.2 programa02.f90, verso B
1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho.
INTEGER A
A = 3
WRITE(*,*) "A"
WRITE(*,*) A
END
2) Comentrios sobre o programa: a nica diferena entre a verso anterior (A) e a atual (B) do
programa02.f90 a incluso 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
varivel do lado esquerdo. Portanto, neste caso, o valor 3 atribudo varivel A. Em outras palavras,
o valor 3 armazenado num espao da memria do computador que identificado pelo nome ou
rtulo A, o nome da varivel. Este valor utilizado (3) apenas um exemplo; ele pode ser qualquer
nmero inteiro.
3) Nesta verso do programa, ao se executar Build, Compile, no haver aviso (warning) porque, neste
caso, o valor da varivel A est definido.
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 compilao apresentado na Figura 2.4. Ele ocorre devido eliminao do
segundo asterisco da terceira linha do programa. Erros de compilao ocorrem quando os comandos
do FORTRAN so utilizados de forma incorreta. Na subjanela inferior do Fortran, geralmente haver
um comentrio indicando cada erro (error). Logo aps o nome do programa-fonte compilado, entre
parnteses, indicado o nmero da linha do programa-fonte aonde deve estar o erro. No exemplo da
Figura 2.4, o compilador do Fortran mostra o seguinte comentrio:
C:\marchi\programa02\programa02b.f90(3): error FOR3852: syntax error detected between , and ).
Portanto, este comentrio indica que na linha 3 h um erro de sintaxe (erro que resulta do uso
incorreto de um comando, no caso o WRITE) entre a vrgula e o sinal de fechamento de parnteses.
8) As linhas do programa-fonte so numeradas do topo para baixo, e as colunas, da esquerda para a
direita. Na extremidade inferior da janela principal do Fortran, do lado direito, sempre so indicados a
linha (Ln) e a coluna (Col) aonde o cursor se encontra dentro do programa-fonte.
Figura 2.3 Resultado da execuo do programa02.f90, verso B.
Figura 2.4 Exemplo de erro de compilao.
2.3 programa02.f90, verso C
INTEGER A
A = 3
WRITE(*,*) "Valor de A = ", A

END
2) Comentrios sobre o programa: a diferena bsica entre a verso anterior (B) e a atual (C) do
programa02.f90 a juno 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, so apenas dois elementos, ou seja, o
comentrio Valor de A = e a varivel A. Os elementos devem ser separados por vrgula.
3) Executar Build, Compile para compilar o programa.
a) Na primeira linha, como resultado do comando WRITE(*,*) "Valor de A = ", A do programa,
o comentrio Valor de A = e, na mesma linha, o valor da varivel A, cujo valor atribudo dentro
do programa foi 3.
b) E na segunda linha, a frase Press any key to continue.
Figura 2.5 Resultado da execuo do programa02.f90, verso C.
2.4 programa02.f90, verso D
INTEGER A
A = 4
A = 3
END
2) Comentrios sobre o programa: a nica diferena entre a verso anterior (C) e a atual (D) do
programa02.f90 a incluso da linha A = 4, que atribui o valor 4 varivel A.

5) Ao se executar o programa, atravs de Build, Execute, o resultado o mesmo mostrado na Figura
2.5. Isso ocorre porque o programa executado, linha por linha, da primeira (INTEGER A) at a ltima
(END). Assim, embora tenha sido atribudo o valor 4 varivel A na segunda linha do programa, na
linha seguinte atribui-se o valor 3 mesma varivel, e, na quarta linha do programa, escreve-se o
valor de A. O valor escrito 3 porque o ltimo valor que foi armazenado na memria do
computador. A denominao varivel usada justamente porque seu valor pode ser alterado ao longo
da execuo do programa.
2.5 programa02.f90, verso E
1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho, incluindo a linha em
branco.
! Programa02.f90
INTEGER A
A = 3 ! atribui o valor 3 varivel A

END
2) Comentrios sobre o programa: em cada linha do programa-fonte, tudo que estiver direita do
smbolo ! (exclamao) no executado pelo programa. So apenas comentrios usados para
esclarecer o que faz cada parte do programa. Isso chamado de documentao interna. Dentro do
editor do Fortran, todos os comentrios ficam na cor verde, como mostrado na Figura 2.6. Um
comentrio pode envolver uma linha inteira do programa, como na primeira da verso E, ou apenas
uma parte, como na quarta linha do programa. Linhas em branco dentro do programa-fonte tambm
no so executadas. Elas equivalem a um comentrio em branco. Um exemplo a terceira linha do
programa02.f90, verso E, na Figura 2.6.
5) Ao se executar o programa, atravs de Build, Execute, o resultado o mesmo mostrado na Figura
2.5. Isso ocorre porque as diferenas entre a verso C e a atual (E) do programa02.f90 so apenas os
comentrios e uma linha em branco, que no so executados pelo programa.
6) Para maior clareza e facilidade de compreenso do programa-fonte, recomenda-se que dentro dele
sejam usados comentrios e linhas em branco.

Figura 2.6 Programa02.f90, verso E.
2.6 programa03.f90, verso A
Para inicializar as atividades com o prximo programa, deve-se executar:

1) No Fortran, para fechar o projeto atual: File, Close Workspace
3) No Fortran, seguindo o procedimento apresentado na seo 1.6 do captulo 1, criar um projeto do tipo
Console Application com o nome programa03 no diretrio Z:\\SERVER1\Alunos2004_1\login,
do DEMEC/UFPR.
4) No Fortran, seguindo o procedimento apresentado na seo 1.7 do captulo 1, criar e inserir no projeto
o programa-fonte programa03.f90
5) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho, incluindo as linhas em
branco.
INTEGER A, B, C, D, E, F, G
A = -6
B = 2
C = A + B
D = B - A
E = A * B
F = A / B
G = A ** B
WRITE(*,*) "A = ", A

WRITE(*,*) "B = ", B
WRITE(*,*) "A + B = ", C
WRITE(*,*) "B - A = ", D
WRITE(*,*) "A * B = ", E
WRITE(*,*) "A / B = ", F
WRITE(*,*) "A ** B = ", G
END

a) A linha INTEGER A, B, C, D, E, F, G define as variveis A, B, C, D, E, F e G como sendo do
tipo inteiro. Este comando reserva espao na memria do computador para diversas variveis com
apenas um comando INTEGER. Entretanto, as variveis devem estar separadas por vrgula.
b) As linhas A = -6 e B = 2 atribuem os valores inteiros 6 e 2 s variveis A e B. Estes valores so
apenas exemplos; eles podem ser quaisquer nmeros inteiros.
c) As variveis C, D, E, F e G so calculadas em funo dos valores das variveis A e B, usando os
cinco operadores matemticos bsicos definidos na Tabela 2.1, conforme explicado a seguir.
Tabela 2.1 Operadores matemticos bsicos em FORTRAN.

Smbolo do operador Nome do smbolo Operao matemtica
matemtico em FORTRAN correspondente
+ Sinal mais Adio
Sinal menos Subtrao
* Asterisco Multiplicao
/ Barra Diviso
** Duplo asterisco Potenciao
d) A linha C = A + B adiciona os valores das variveis A e B e atribui o resultado varivel C.

e) A linha D = B - A subtrai o valor da varivel A do valor da varivel B e atribui o resultado
varivel D.
f) A linha E = A * B multiplica os valores das variveis A e B e atribui o resultado varivel E.
g) A linha F = A / B divide o valor da varivel A pelo valor da varivel B e atribui o resultado
varivel F.

h) A linha G = A ** B eleva o valor da varivel A ao valor da varivel B e atribui o resultado
varivel G.
dentro da qual tem-se: os valores das variveis A e B; e os valores resultantes das cinco operaes
matemticas bsicas da Tabela 2.1 efetuadas com as variveis A e B. Analisar cada resultado,
comparando-o com o valor esperado obtido de um clculo mental.
10) Dentro do programa-fonte, fazer A = 1 e B = 2. Compilar e gerar o executvel do programa com
esta alterao. Executar o programa cujo resultado deve ser aquele mostrado na Figura 2.8.
Analisar cada resultado, comparando-o com o valor esperado obtido de um clculo mental. O
resultado da diviso pode parecer incorreto mas no . Isso se deve ao seguinte: o valor que resulta de
um clculo envolvendo dois nmeros inteiros tambm um nmero inteiro, que corresponde parte
inteira do nmero real equivalente ao clculo realizado. Portanto, o resultado de 1 dividido por 2
resulta em 0,5, que um nmero real. Mas como o clculo envolve dois nmeros inteiros, a parte
inteira do nmero real 0,5 0, que o resultado da diviso mostrado na Figura 2.8. Este tema ser
explorado com mais detalhes no Captulo 3.
Figura 2.7 Resultado da execuo do programa03.f90, verso A, com A = 6 e B = 2.
Figura 2.8 Resultado da execuo do programa03.f90, verso A, com A = 1 e B = 2.

11) Atribuir valores s variveis dentro do prprio programa-fonte no recomendvel. Pois, para alterar
os valores, necessrio ter o programa-fonte, alm de recompil-lo e gerar o programa-executvel a
cada vez. O procedimento mais indicado utilizar o comando READ, apresentado na prxima seo.
2.7 programa03.f90, verso B
1) Dentro do Fortran, alterar o programa03.f90, verso 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
WRITE(*,*) "Entre com o valor de A"

READ(*,*) A
WRITE(*,*) "Entre com o valor de B"

READ(*,*) B
C = A + B
D = B - A
E = A * B
F = A / B
G = A ** B
WRITE(*,*) "A = ", A

WRITE(*,*) "B = ", B
WRITE(*,*) "A + B = ", C
WRITE(*,*) "B - A = ", D
WRITE(*,*) "A * B = ", E
WRITE(*,*) "A / B = ", F
WRITE(*,*) "A ** B = ", G
END

a) A nica diferena entre a verso anterior (A) e a atual (B) do programa03.f90 est no nicio do
programa. a incluso de 4 linhas novas no lugar de se atribuir valores s variveis A e B.
b) At aqui, os comandos da linguagem FORTRAN que foram usados so: WRITE, END e
INTEGER. Na verso B do programa03.f90, h um novo comando: READ. Ele usado para
atribuir (fornecer) valores s variveis durante a execuo de um programa. Isto , o comando
READ empregado para LER os dados de um programa.
c) A linha WRITE(*,*) "Entre com o valor de A" escreve o comentrio que est entre aspas.
d) A linha READ(*,*) A l um valor digitado dentro da janela DOS, aberta durante a execuo do
programa, e o atribui varivel A.
5) Ao se executar o programa, atravs de Build, Execute, surge uma janela do tipo DOS dentro da qual
tem-se:
a) Na primeira linha, o comentrio Entre com o valor de A, resultado do comando WRITE(*,*)
"Entre com o valor de A" do programa.
b) Na segunda linha, o programa pra e fica aguardando que seja fornecido o valor da varivel A,
resultado do comando READ(*,*) A do programa. Para que o programa continue sua execuo
necessrio digitar o valor 6 para a varivel A e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentrio Entre com o valor de B, resultado do comando WRITE(*,*)
"Entre com o valor de B" do programa.
d) Na quarta linha, o programa pra e fica aguardando que seja fornecido o valor da varivel B,
resultado do comando READ(*,*) B do programa. Para que o programa continue sua execuo
necessrio digitar o valor 2 para a varivel B e, em seguida, clicar na tecla enter.
e) Em seguida, so apresentados os mesmos resultados da verso A do programa03.f90, conforme a
Figura 2.9.
Figura 2.9 Resultado da execuo do programa03.f90, verso B, com A = 6 e B = 2.
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 clculo mental.
7) Executar novamente o programa, com A = 6 e B = 0. Nenhum resultado apresentado porque o
programa no consegue dividir 6 por 0. Isso gera um erro que interrompe a execuo normal do
programa. Ao se implementar um programa, deve-se prepar-lo para que seja evitado qualquer

diviso por zero. Isso pode ser feito atravs de comentrios que informem ao usurio do programa, na
janela da execuo do programa ou no manual do programa, por exemplo, quais as variveis que no
podem ter valor nulo. Outra forma mais efetiva de evitar diviso por zero ser vista em captulo
futuro.
2.8 FIM DA SESSO

Workspace
2.9 EXERCIOS
Exerccio 2.1
Executar novamente o programa03.f90, verso B, com A = 2 e B = 1. Em seguida, analisar cada
resultado, comparando-o com o valor esperado obtido de um clculo mental, especialmente o caso da
potenciao. No Fortran, para abrir um projeto j existente, como o programa03, basta executar File,
Open Workspace. Em seguida, indicar o diretrio do projeto e selecionar o arquivo que tem o nome
do projeto e extenso mdp, no caso programa03.mdp
Exerccio 2.2
Executar novamente o programa03.f90, verso B, usando nmeros reais, isto , A = 1.5 e B = 0.4.
Nmeros reais so representados com o sinal de ponto para separar a parte inteira da decimal.
Exerccio 2.3
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler trs nmeros inteiros
b) calcular a mdia aritmtica deles
c) escrever os valores lidos e o valor da mdia aritmtica juntamente com comentrios para
identific-los
4) Executar o programa com os valores 1, 2 e 3. Em seguida, analisar o resultado da mdia fornecido
pelo programa comparando-o com o valor esperado obtido por um clculo mental.
5) Repetir o item 4 para os valores 1, 1 e 2.
Exerccio 2.4
a) ler o primeiro valor (inteiro) de uma progresso aritmtica (P.A.), denotado por A1
b) ler a diferena (nmero inteiro) entre dois termos subseqentes da P.A., denotada por D
c) ler o nmero (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 trs valores lidos e os dois calculados juntamente com comentrios para identific-los
4) Executar o programa para A1 = 1, D = 3 e N = 5. Os resultados devem ser AN = 13 e SN = 35.

Captulo 3. VARIVEIS DO TIPO REAL
Conceitos de: variveis do tipo real, traduo de expresses algbricas em FORTRAN, mistura de
variveis do tipo inteiro com real, prioridade nas operaes matemticas
Operadores matemticos bsicos
Comando do FORTRAN: REAL
3.1 programa03c.f90

1) No Windows: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
2) Neste captulo ser usado um projeto j existente, no caso o projeto do fim do captulo 2. Para abri-lo,
deve-se executar o seguinte no Fortran:
a) File, Open Workspace
b) Indicar o diretrio do projeto chamado programa03
c) Selecionar o arquivo que tem o nome do projeto e extenso mdp, no caso programa03.mdp
d) Na subjanela do lado esquerdo do Fortran, clicar sobre o sinal + ao lado do nome do projeto;
dever aparecer o nome do ltimo programa-fonte que foi inserido neste projeto
e) Clicar sobre o nome do programa-fonte
f) Edit, Cut para retirar o programa-fonte do projeto. Este comando no deletar o programa-fonte.
Ele apenas o retirar do projeto. Quando se quiser, ele poder ser inserido no projeto novamente,
bastando para isso selecionar o programa-fonte desejado dentro do seu diretrio e usar o comando
Insert, Files into Project.
3) No Fortran, seguindo o procedimento apresentado na seo 1.7 do captulo 1, criar e inserir no
projeto chamado programa03 o programa-fonte programa03c.f90
copiar exatamente o texto em vermelho mostrado na Tabela 3.1.
a) Nos captulos 1 e 2 foram usados os comandos WRITE, END, INTEGER e READ da linguagem
FORTRAN. No programa03c.f90 h um novo comando: REAL. Ele usado para definir variveis
do tipo real, isto , variveis que podem guardar ou armazenar na memria do computador
Captulo 3. Variveis do tipo real 37

nmeros reais, positivos ou negativos, como 1.0, 1.0, 1.1, 3.1416 ou 0.003.
b) No FORTRAN, nmeros reais so representados com o sinal de ponto para separar a parte inteira
da decimal. Deve-se lembrar que em portugus se usa a vrgula com este fim.
c) A linha REAL A define a varivel A como sendo do tipo real. Este comando reserva um espao na
memria do computador, utilizando o nome ou rtulo A para armazenar um valor real. As demais
linhas do programa j foram comentadas no captulo 2.
Tabela 3.1 Programa03c.f90.

REAL A
WRITE(*,*) "Entre com o valor de A ="
READ(*,*) A
END
Figura 3.1 Programa03c.f90.
6) Executar Build, Compile para compilar o programa


necessrio digitar o valor 1 para a varivel A, por exemplo, e, em seguida, clicar na tecla
enter.
c) Na terceira linha, o comentrio Valor de A = e o valor da varivel A, resultado do comando
WRITE(*,*) "Valor de A = ", A do programa. Deve-se notar que foi fornecido um valor
inteiro para a varivel A, no caso 1. Mas o resultado do programa mostra o valor 1.000000
porque a varivel 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 execuo do programa encerrada.
Figura 3.2 Resultado da execuo do programa03c.f90 com A = 1.
9) Executar novamente o programa, atravs de Build, Execute, com A = 0.0031. Junto a um nmero
real, a letra E usada para representar nmeros muito grandes ou muito pequenos atravs da chamada
notao cientfica ou exponencial. Desta forma, o valor 3.100000E-03 da varivel A, mostrado na
Figura 3.3, significa 3.1x10-3, que igual a 0.0031.
Figura 3.3 Resultado da execuo do programa03c.f90 com A = 0.0031.
10) Executar novamente o programa, atravs de Build, Execute, com A = 1.0E+2. Pode-se fornecer
dados ao programa usando a notao cientfica ou exponencial, como no exemplo mostrado na Figura
3.4, onde A = 1.0E+2 = 1.0x102 = 100 = 1.0E2 = 1E2.

Figura 3.4 Resultado da execuo do programa03c.f90 com A = 1.0E+2.
3.2 programa03d.f90
1) Nesta seo ser usado um projeto j existente, no caso o projeto da seo 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.
projeto chamado programa03 o programa-fonte programa03d.f90
3) Dentro do espao de edio do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 3.2.
Tabela 3.2 Programa03d.f90.

INTEGER D
REAL A, B, C

READ(*,*) A
D = A
B = 1 / D
C = 1.0 / D
WRITE(*,*) "Valor de D = ", D

WRITE(*,*) "Valor de B = ", B
WRITE(*,*) "Valor de C = ", C
END


necessrio digitar o valor 2.9 para a varivel A, por exemplo, e, em seguida, clicar na tecla
enter.
c) Nas linhas seguintes, os resultados das variveis D, B e C.
Figura 3.5 Resultado da execuo do programa03d.f90.
7) Comentrios sobre os resultados do programa03d.f90 mostrados na Figura 3.5:

a) Na linha D = A do programa, o valor da varivel real A atribudo varivel inteira D. Portanto,
apenas a parte inteira do nmero A passada varivel D, desprezando-se a parte decimal.
b) Na linha B = 1 / D do programa, o resultado da diviso do nmero 1 (inteiro) pela varivel
inteira D atribudo varivel real B. Conforme visto no captulo 2, o valor que resulta de um
clculo envolvendo dois nmeros inteiros tambm um nmero inteiro, que corresponde parte
inteira do nmero real equivalente ao clculo realizado. Portanto, o resultado de 1 dividido por 2
(varivel D) resulta em 0.5, que um nmero real. Mas como o clculo envolve dois nmeros
inteiros, a parte inteira do nmero real 0.5 0, que o resultado da varivel B mostrado na Figura
3.5. Assim, apenas a parte inteira da diviso 1 / D passada varivel real B, desprezando-se a
parte decimal.
c) Na linha C = 1.0 / D do programa, o resultado da diviso do nmero 1.0 (real) pela varivel
inteira D atribudo varivel real C. Neste caso, o clculo envolve a diviso de um nmero real
(1.0) por um nmero inteiro (D). O resultado da varivel C mostrado na Figura 3.5 igual a 0.5,
que um nmero real. Isso ocorre porque o valor que resulta de um clculo envolvendo um
nmero inteiro e um nmero real um nmero real.
3.3 programa03e.f90
1) Nesta seo ser usado um projeto j existente, no caso o projeto da seo anterior. Portanto, deve-se
executar o seguinte no Fortran:
projeto chamado programa03 o programa-fonte programa03e.f90
Tabela 3.3 Programa03e.f90.

REAL A, B, C, D, E, F, G

READ(*,*) A

READ(*,*) B
C = A + B
D = B - A
E = A * B
F = A / B
G = A ** B
WRITE(*,*) "A = ", A

WRITE(*,*) "B = ", B
WRITE(*,*) "A + B = ", C
WRITE(*,*) "B - A = ", D
WRITE(*,*) "A * B = ", E
WRITE(*,*) "A / B = ", F
WRITE(*,*) "A ** B = ", G
END


necessrio digitar o valor 1.5 para a varivel A, por exemplo, e, em seguida, clicar na tecla
enter.
necessrio digitar o valor 0.4 para a varivel B, por exemplo, e, em seguida, clicar na tecla
enter.
e) Nas linhas seguintes, os resultados das variveis C, D, E, F e G.
Figura 3.6 Resultado da execuo do programa03e.f90.
7) Analisar cada resultado mostrado na Figura 3.6 comparando-o com o valor esperado obtido de um
clculo 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 clculo mental ou com o uso de uma calculadora.
3.4 ESCALA DE PRIORIDADES ENTRE OS OPERADORES MATEMTICOS
Na linguagem FORTRAN, as operaes matemticas so executadas numa seqncia lgica de

acordo com uma escala de prioridades entre elas, que apresentada na Tabela 3.4. Alm disso so
consideradas as regras descritas na Tabela 3.5. importante conhecer estas prioridades e regras para se
fazer corretamente a traduo de expresses algbricas em expresses na linguagem FORTRAN, dentro
de um programa-fonte. Alguns exemplos de expresses algbricas so apresentados abaixo nas Equaes
(3.1) a (3.8).
Tabela 3.4 Escala de prioridades entre os operadores matemticos bsicos em FORTRAN.

Prioridade Smbolo Nome do smbolo Operao
1a ( ) Parnteses Qualquer
2a ** Duplo asterisco Potenciao
3a * Asterisco Multiplicao
/ Barra Diviso
4a + Sinal mais Adio
Sinal menos Subtrao
Tabela 3.5 Regras adotadas nas operaes matemticas em FORTRAN.

Item Regra
1 No caso de operaes matemticas que tm a mesma prioridade (multiplicao e diviso ou
adio e subtrao), executa-se primeiro o clculo mais esquerda
2 Parnteses so usados para que os clculos sejam executados na ordem que se deseja. Com eles,
a ordem de execuo do parnteses mais interno para o mais externo.
3 Com duas ou mais potenciaes consecutivas, a ordem de execuo da direita para a esquerda.
4 O valor que resulta de um clculo envolvendo dois nmeros inteiros tambm um nmero
inteiro, que corresponde parte inteira do nmero real equivalente ao clculo realizado.
5 Uma operao envolvendo um nmero real com um nmero inteiro resulta num nmero real.
6 A atribuio de um nmero real a uma varivel do tipo inteiro resulta num nmero inteiro que
trunca a parte decimal do nmero real.
7 A atribuio de um nmero inteiro a uma varivel do tipo real resulta num nmero real.
8 Quando se somam ou se subtraem dois nmeros com magnitudes muito diferentes, possvel
que o valor menor seja desprezado. A isso se denomina de erro de arredondamento ou de
truncamento.
9 Espaos em branco entre variveis, sinais de igualdade, parnteses, nmeros ou operadores
matemticos no interferem no resultado dos clculos. Eles tm apenas funo esttica.
H1 = A + B C (3.1)
B
H2 = A + (3.2)
C

A + B
H3 = (3.3)
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 seo ser usado um projeto j existente, no caso o projeto da seo 3.3 deste captulo.
Portanto, deve-se executar o seguinte no Fortran:
projeto chamado programa03 o programa-fonte programa03f.f90
a) Nas duas primeiras linhas usado o comando REAL para definir as variveis 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 variveis. Um
nico comando READ pode ser usado para a leitura de diversos valores que so atribudos a
diversas variveis, que tm que estar separadas por vrgula.
c) As expresses em FORTRAN para as variveis H1 a H6, H9 e H10 correspondem
respectivamente s expresses algbricas dadas pelas Equaes (3.1) a (3.8).

Tabela 3.6 Programa03f.f90.
REAL A, C, B, D
REAL H1, H2, H3, H4, H5, H6, H7, H8, H9, H10, H11, H12
WRITE(*,*) "Entre com os valores de A, C, B e D"

READ(*,*) A, C, B, D
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
H10 = (1.0 / 3 ) * ( (B**3) ** (1 / 2.0) )

H11 = (1.0 / 3.0) * ( (B**3) ** (1.0 / 2.0) )
H12 = (1 / 3 ) * ( (B**3) ** (1 / 2 ) )
WRITE(*,*) "H1 = ", H1

WRITE(*,*) "H2 = ", H2
WRITE(*,*) "H3 = ", H3
WRITE(*,*) "H4 = ", H4
WRITE(*,*) "H5 = ", H5
WRITE(*,*) "H6 = ", H6
WRITE(*,*) "H7 = ", H7
WRITE(*,*) "H8 = ", H8
WRITE(*,*) "H9 = ", H9
WRITE(*,*) "H10 = ", H10
WRITE(*,*) "H11 = ", H11
WRITE(*,*) "H12 = ", H12
END

d) A expresso em FORTRAN para a varivel H7 corresponde expresso algbrica dada pela
Equao (3.6).
e) As expresses em FORTRAN para as variveis H11 e H12 correspondem expresso algbrica
dada pela Equao (3.8). Porm, na expresso de H12 so usados apenas nmeros inteiros nas
divises.
f) A expresso em FORTRAN para a varivel H8 corresponde a uma simples soma de dois nmeros
reais, um muito pequeno em relao ao outro.
Figura 3.7 Resultado da execuo do programa03f.f90.
a) Na primeira linha, o comentrio Entre com os valores de A, C, B e D, resultado do comando

WRITE(*,*) "Entre com os valores de A, C, B e D" do programa.
b) Na segunda linha, o programa pra e fica aguardando que sejam fornecidos os valores da variveis
A, C, B e D, resultado do comando READ(*,*) A, C, B, D do programa. Para que o programa
continue sua execuo necessrio digitar quatro valores. Cada valor digitado ser atribudo
respectivamente a uma das quatro variveis, na mesma seqncia. H vrias formas de se entrar
com diversos valores para um nico comando READ: digitando tudo na mesma linha, com cada
valor separado por vrgula ou espao em branco; digitando cada valor e, em seguida, clicando na
tecla enter; ou misturas das trs 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 variveis A, C, B e
D.
c) Nas linhas seguintes, os resultados das variveis H1 a H12.

8) Analisar cada resultado mostrado na Figura 3.7 comparando-o com o valor esperado obtido de um
clculo mental ou com o uso de uma calculadora. Para tanto, devem ser consideradas a escala de
prioridades da Tabela 3.4 e as regras descritas na Tabela 3.5.
9) Executar novamente o programa com outros valores para as variveis A, C, B e D. Analisar cada
novo resultado comparando-o com o valor esperado obtido de um clculo mental ou com o uso de
uma calculadora.
10) Para concluir o uso do Fortran e do Windows, deve-se executar os passos mostrados na seo 2.8 do
captulo 2.
3.6 EXERCCIOS
Exerccio 3.1
Escrever as expresses em linguagem FORTRAN que correspondem s seguintes expresses algbricas,
onde A, B e L so nmeros reais e I e J so nmeros inteiros:
Para verificar se a resposta de cada item est correta, basta implementar a expresso em FORTRAN num
programa e comparar seu resultado com o valor obtido com uma calculadora para a expresso algbrica
correspondente. Os dois resultados devem ser iguais. Isso tambm vale para o prximo exerccio.

Exerccio 3.2
Escrever as expresses algbricas que correspondem s seguintes expresses em linguagem FORTRAN:
a) A = ( ( B**(1.0/2) ) + 5) / 100
b) A = (1.0/10) + ( B**(1/3.0) )
c) L = (1.0/(3.0 I)) * ( ( (I**2) + (1.0/(J**3)) ) ** (1.0/2) )

d) L = ( 1.0 / ( 1.0 + (1.0/I) ) ) * ( ( (I**2) + ( J / ( (I**3) 2 ) ) ) ** (1.0/3) )
Exerccio 3.3
a) ler trs nmeros reais
b) calcular a mdia aritmtica deles
c) escrever os valores lidos e o valor da mdia aritmtica juntamente com comentrios para
identific-los
4) Executar o programa com os valores 1.0, 2.5 e 3.7. Em seguida, analisar o resultado da mdia
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.
Exerccio 3.4
a) ler o primeiro valor (real) de uma progresso aritmtica (P.A.), denotado por A1
b) ler a diferena (nmero real) entre dois termos subseqentes da P.A., denotada por D
d) calcular o valor (real) do ltimo termo da P.A., denotado por AN
f) escrever os trs valores lidos e os dois calculados juntamente com comentrios para identific-los
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.

Captulo 4. VARIVEIS DO TIPO CARACTER
Conceitos de: variveis do tipo caracter, strings, funes intrnsecas
Funes intrnsecas do FORTRAN para variveis do tipo caracter: ADJUSTL, ADJUSTR, TRIM e
LEN
Comando do FORTRAN: CHARACTER
4.1 programa4a.f90

2) No Fortran, seguindo o procedimento apresentado na seo 1.6 do captulo 1, criar um projeto do
tipo Console Application com o nome programa04 no diretrio Z:\\SERVER1\Alunos2004_1\login,
do DEMEC/UFPR.
projeto o programa-fonte programa4a.f90
a) Nos captulos 1 a 3 foram usados os comandos WRITE, END, INTEGER, READ e REAL da
linguagem FORTRAN. No programa4a.f90 h um novo comando: CHARACTER. Ele usado
para definir variveis do tipo caracter ou string, isto , variveis que podem guardar ou armazenar
comentrios na memria do computador. Estes comentrios podem incluir palavras, nmeros,
smbolos, espaos em branco ou frases. Alguns exemplos so (os contedos das variveis esto
separados por vrgula): UFPR, 5 de abril de 2004, teste de hoje, TM-102, U-20/5%, L&L. As
variveis do tipo caracter tambm so chamadas de alfanumricas porque envolvem letras e
nmeros.
b) No FORTRAN, o contedo ou string de uma varivel do tipo caracter definido entre aspas.
c) A linha CHARACTER A declara a varivel A como sendo do tipo caracter. Este comando reserva um
espao na memria do computador, utilizando o nome ou rtulo A, para armazenar um nico
Captulo 4. Variveis do tipo caracter 50

caracter alfanumrico.
d) A linha A = "UFPR, Curitiba, PR" atribui o contedo entre aspas varivel A.
Tabela 4.1 Programa4a.f90, verso 1.

CHARACTER A
A = "UFPR, Curitiba, PR"
WRITE(*,*) "Conteudo de A = ", A
END
Figura 4.1 Programa4a.f90, verso 1.

a) Na primeira linha, o comentrio Conteudo de A =, e, em seguida, a letra U, resultado do comando
WRITE(*,*) "Conteudo de A = ", A do programa.
b) Na segunda linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer

Figura 4.2 Resultado da execuo do programa4a.f90, verso 1.
9) No FORTRAN, cada varivel do tipo caracter deve ser declarada com a dimenso adequada
quantidade mxima de letras, nmeros, espaos em branco e smbolos que ela poder conter. Quando
no se declara o tamanho, assume-se que seja apenas um caracter. Devido a isso, somente a letra U foi
apresentada como contedo da varivel A, na verso 1 do programa4a.f90, embora ela tenha sido
definida com muito mais caracteres.
10) Para declarar a dimenso de uma varivel do tipo caracter, basta colocar o tamanho entre parnteses
junto palavra character, como exemplificado na verso 2 do programa4a.f90, na Tabela 4.2.
Tabela 4.2 Programa4a.f90, verso 2.

CHARACTER(50) A
A = "UFPR, Curitiba, PR"
END
11) Alterar a primeira linha do programa4a.f90 para ficar igual Tabela 4.2. Compilar novamente o
programa e gerar seu executvel. Executar o programa. Agora, conforme a Figura 4.3, apresentado
o contedo completo da varivel A, j que ele ocupa apenas 18 caracteres e a varivel A foi
dimensionada prevendo at 50 caracteres.
Figura 4.3 Resultado da execuo do programa4a.f90, verso 2.

4.2 programa4b.f90
1) Nesta seo ser usado o mesmo projeto da seo anterior. Portanto, deve-se executar o seguinte no
Fortran:
projeto chamado programa04 o programa-fonte programa4b.f90
a) A linha CHARACTER(50) A declara a varivel A como sendo do tipo caracter. Este comando
reserva um espao na memria do computador, utilizando o nome ou rtulo A, para armazenar at
50 caracteres alfanumricos.
b) O comando READ do FORTRAN tambm pode ser usado para atribuir valor ou contedo a
uma varivel do tipo caracter, desde que o contedo esteja entre aspas. Um exemplo mostrado na
linha READ(*,*) A.
Tabela 4.3 Programa4b.f90.

CHARACTER(50) A
WRITE(*,*) "Entre com o conteudo de A ="
READ(*,*) A
END

a) Na primeira linha, o comentrio Entre com o conteudo de A =, resultado do comando WRITE(*,*)
"Entre com o conteudo de A =" do programa.
b) Na segunda linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel A,
necessrio digitar, entre aspas, um contedo para a varivel A, por exemplo, Teste de hoje e,
em seguida, clicar na tecla enter.
c) Na terceira linha, o contedo da varivel A.
Figura 4.4 Resultado da execuo do programa4b.f90.
8) Executar novamente o programa, atravs de Build, Execute, testando outros contedos para a
varivel A e vendo o resultado. Testar, por exemplo, uma frase com pelo menos duas palavras mas
sem usar aspas para definir o contedo de A.
4.3 programa4c.f90
Fortran:
a) A linha CHARACTER(20) LOCAL, DIA declara duas variveis, LOCAL e DIA, como sendo do tipo
caracter, cada uma podendo armazenar at 20 caracteres alfanumricos.
b) A linha CHARACTER(10) HORA declara a varivel HORA como sendo do tipo caracter, podendo
armazenar at 10 caracteres alfanumricos.
c) A linha CHARACTER(90) FRASE declara a varivel FRASE como sendo do tipo caracter, podendo
armazenar at 90 caracteres alfanumricos.
d) A linha FRASE = "Frase: " // LOCAL // ", " // DIA // ", as " // HORA // " horas"
define o contedo da varivel FRASE com base em alguns comentrios que esto entre aspas e no
contedo das variveis LOCAL, DIA e HORA. Isso possvel devido ao uso do operador de
concatenao cujo smbolo composto por duas barras (//). Este operador permite juntar duas ou
mais variveis do tipo caracter.

CHARACTER(20) LOCAL, DIA
CHARACTER(10) HORA
CHARACTER(90) FRASE
WRITE(*,*) "Entre com o local ="

READ(*,*) LOCAL
WRITE(*,*) "Entre com o dia ="
READ(*,*) DIA
WRITE(*,*) "Entre com a hora ="
READ(*,*) HORA
FRASE = "Frase: " // LOCAL // ", " // DIA // ", as " // HORA // " horas"
WRITE(*,*) "Conteudo de FRASE = ", FRASE
END

a) Na primeira linha, o comentrio Entre com o local =, resultado do comando WRITE(*,*) "Entre
com o local =" do programa.
b) Na segunda linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel
LOCAL, resultado do comando READ(*,*) LOCAL do programa. Para que o programa continue
sua execuo necessrio digitar o contedo da varivel LOCAL, por exemplo, Curitiba e,
c) Na terceira linha, o comentrio Entre com o dia =, resultado do comando WRITE(*,*) "Entre
com o dia =" do programa.
d) Na quarta linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel
DIA, resultado do comando READ(*,*) DIA do programa. Para que o programa continue sua
execuo necessrio digitar o contedo da varivel DIA, por exemplo, 5 de abril de 2004 e,
e) Na quinta linha, o comentrio Entre com a hora =, resultado do comando WRITE(*,*) "Entre
com a hora =" do programa.
f) Na sexta linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel
HORA, resultado do comando READ(*,*) HORA do programa. Para que o programa continue sua

execuo necessrio digitar o contedo da varivel HORA, por exemplo, 10:58 e, em
seguida, clicar na tecla enter.
g) Na stima linha, o comentrio Contedo de FRASE = e, em seguida, o contedo da varivel
FRASE, resultado do comando WRITE(*,*) "Conteudo de FRASE = ", FRASE do programa e
da linha anterior aonde se definiu a varivel FRASE.
Figura 4.5 Resultado da execuo do programa4c.f90.
8) Deve-se notar na Figura 4.5 que a escrita do contedo da varivel FRASE ocupou mais de uma linha.
Isso ocorre devido a sua extenso ser muito grande, isto , superior ao nmero disponvel de colunas
numa janela do tipo DOS.
9) No FORTRAN, se o contedo de uma varivel definido com menos caracteres do que o mximo
declarado, a diferena entre os caracteres ocupados e o mximo previsto preenchida com espaos
em branco, como no contedo da varivel FRASE. Por exemplo, a varivel LOCAL foi declarada
com tamanho mximo de 20 caracteres. Mas seu contedo foi definido com Curitiba, palavra que
ocupa apenas 8 caracteres. Neste caso, os demais 12 caracteres so preenchidos com espaos em
branco. O mesmo problema ocorre com as demais variveis. Formas de se resolver este problema so
abordadas na prxima seo.
10) Executar novamente o programa com outros contedos para as variveis LOCAL, DIA e HORA.
4.4 programa4d.f90
1) Nesta seo ser usado o mesmo projeto da seo anterior deste captulo. Portanto, deve-se executar o
seguinte no Fortran:

CHARACTER(9) A
INTEGER L
WRITE(*,*) "Entre com o conteudo de A ="

WRITE(*,*) "0123456789"
READ(*,*) A
WRITE(*,*) " 0123456789"

WRITE(*,*) "A =(", A, ")"
WRITE(*,*) "Com ADJUSTL =(", ADJUSTL(A), ")"
WRITE(*,*) "Com ADJUSTR =(", ADJUSTR(A), ")"
WRITE(*,*) "Com TRIM =(", TRIM(A), ")"
WRITE(*,*) "Com ADJUSTL e TRIM =(", TRIM(ADJUSTL(A)), ")"
L = LEN(A)
WRITE(*,*) "L de A = ", L
L = LEN(TRIM(ADJUSTL(A)))
WRITE(*,*) "L de A com TRIM e ADJUSTL = ", L
END

a) A linha CHARACTER(9) A declara a varivel A como sendo do tipo caracter, podendo armazenar
at 9 caracteres alfanumricos.
b) A linha INTEGER L declara a varivel L como sendo do tipo inteiro.
c) Conforme pode-se ver na Figura 4.6, ADJUSTL, ADJUSTR, TRIM e LEN esto escritos em azul
dentro do Fortran. Elas so chamadas de funes intrnsecas do FORTRAN, ou seja, so funes
ou comandos que existem dentro da linguagem FORTRAN. Estas funes so usadas para
manipular strings, isto , contedos de variveis do tipo caracter.
d) A lista completa das funes para variveis do tipo caracter pode ser vista no manual do Fortran.
Para acess-lo, dentro da subjanela do lado esquerdo, deve-se executar: clicar uma vez sobre o
smbolo ?InfoView; e acessar as opes Reference, Procedures, Character Procedures.
e) A linha WRITE(*,*) "A =(", A, ")" escreve em seqncia o contedo de
trs strings que esto separadas por vrgula. A primeira o comentrio A =(;

a segunda, o contedo da varivel A; e a terceira, ). As quatro linhas seguintes do programa
fazem o mesmo, isto , cada uma escreve trs strings em seqncia. Mas, nestes casos, em vez de
escrever o contedo da varivel A, escreve-se o resultado de alguma funo operando sobre A,
conforme as explicaes a seguir.
Figura 4.6 Programa4d.f90.
f) A funo ADJUSTL elimina os espaos em branco que esto esquerda de uma string e os passa
direita dela.
g) A funo ADJUSTR elimina os espaos em branco que esto direita de uma string e os passa
esquerda dela.
h) A funo TRIM elimina os espaos em branco que esto direita de uma string.
i) O resultado das funes ADJUSTL, ADJUSTR e TRIM so strings.
j) A funo LEN conta o nmero de caracteres de uma string ou varivel do tipo caracter. Seu
resultado um nmero inteiro.
k) Na instruo TRIM(ADJUSTL(A)) do programa, a funo TRIM opera sobre o resultado da funo
ADJUSTL sobre a varivel A.
l) Na linha L = LEN(A) do programa, a funo LEN opera sobre a varivel A e atribui o resultado
varivel inteira L.

m) Na linha L = LEN(TRIM(ADJUSTL(A))) do programa, a funo LEN opera sobre o resultado da
funo TRIM, que opera sobre o resultado da funo ADJUSTL sobre a varivel A. Finalmente, o
resultado da funo LEN atribudo varivel inteira L.
a) Na primeira linha, o comentrio Entre com o conteudo de A =, resultado do comando WRITE(*,*)
"Entre com o conteudo de A =" do programa.
Figura 4.7 Resultado da execuo do programa4d.f90.
b) Na segunda linha, o comentrio 0123456789, resultado do comando WRITE(*,*) "0123456789"

do programa. Este comentrio uma espcie de rgua para se perceber claramente o nmero de
caracteres usados para definir a varivel A, e quantos espaos em branco existem antes da string
de A e depois dela. O zero usado porque a definio da varivel A exige o sinal de aspas, que
no conta em seu contedo.
c) Na terceira linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel A,
necessrio digitar o contedo da varivel A, por exemplo, Rio 45 e, em seguida, clicar na
tecla enter . Deve-se perceber que h um espao em branco antes da palavra Rio.
d) Na quarta linha, 20 espaos em branco seguidos pelo comentrio 0123456789, resultado do
comando WRITE(*,*) " 0123456789" do programa. Este comentrio
uma espcie de rgua para se perceber claramente os resultados a seguir.
e) Nas linhas seguintes, so apresentados os resultados do contedo da varivel A e das funes
ADJUSTL, ADJUSTR, TRIM e LEN operando sobre a varivel A. Os sinais ( e ) marcam o nicio
e o fim de cada string.

8) Analisar cada resultado mostrado na Figura 4.7, considerando o contedo da varivel A e as
definies apresentadas acima, nesta seo, para as funes ADJUSTL, ADJUSTR, TRIM e LEN.
9) Executar novamente o programa com outros contedos para a varivel A. Analisar os resultados de
cada nova execuo do programa.
10) Para concluir o uso do Fortran e do Windows, deve-se executar os passos mostrados na seo 2.8 do
captulo 2.
4.5 EXERCCIO
Exerccio 4.1
a) declarar quatro variveis do tipo caracter com dimenso de 5, 10, 20 e 30 caracteres
b) ler o contedo das quatro variveis
c) escrever o contedo de cada uma das quatro variveis
d) usando o operador de concatenao, escrever combinaes das quatro variveis lidas
e) aplicar e escrever o resultado da funo ADJUSTL a cada uma das quatro variveis lidas
f) aplicar e escrever o resultado da funo ADJUSTR a cada uma das quatro variveis lidas
g) aplicar e escrever o resultado da funo TRIM a cada uma das quatro variveis lidas
h) aplicar e escrever o resultado da funo TRIM(ADJUSTL) a cada uma das quatro variveis lidas
i) aplicar e escrever o resultado da funo LEN a cada uma das quatro variveis lidas
j) aplicar e escrever o resultado da funo LEN(TRIM(ADJUSTL)) a cada uma das quatro variveis
lidas
4) Executar o programa. Em seguida, comparar os resultados escritos com o esperado para cada caso.

Captulo 5. ARQUIVOS E FUNES MATEMTICAS INTRNSECAS
Conceitos de: arquivo de sada, biblioteca, funes matemticas intrnsecas
Criar e usar arquivos para mostrar resultados da execuo de um programa em FORTRAN
Usar o aplicativo Notepad do Windows para mostrar o contedo de um arquivo durante a execuo de
um programa em FORTRAN
Funes matemticas intrnsecas do FORTRAN
Comandos do FORTRAN: WRITE(nmero,*), OPEN, CLOSE, USE, SYSTEM
5.1 programa5a.f90

2) No Fortran, seguindo o procedimento apresentado na seo 1.6 do captulo 1, criar um projeto do
tipo Console Application com o nome programa05 no diretrio Z:\\SERVER1\Alunos2004_1\login,
do DEMEC/UFPR.
projeto o programa-fonte programa5a.f90
a) At aqui o comando WRITE foi utilizado com dois asteriscos dentro do parnteses, isto , foi
usado na forma WRITE(*,*). O primeiro asterisco do comando WRITE representa o local ou
dispositivo que usado para escrever algum comentrio ou resultado do programa. Este
asterisco pode ser substitudo por um nmero. O nmero 6 representa uma janela do DOS, como
aquela que vem sendo usada at aqui para apresentar os resultados dos programas; por exemplo, a
janela mostrada na Figura 5.2. Portanto, o uso de asterisco no comando WRITE equivale a
empregar o nmero 6.
b) A nica diferena entre o programa5a.f90 e o programa3c.f90, da seo 3.1 do captulo 3, o uso
do nmero 6 no lugar do primeiro asterisco dos comandos WRITE.
Captulo 5. Arquivos e funes matemticas intrnsecas 55

a) Na primeira linha, o comentrio Entre com o valor de A =, resultado do comando WRITE(6,*)
"Entre com o valor de A =" do programa.
Tabela 5.1 Programa5a.f90.

REAL A
WRITE(6,*) "Entre com o valor de A ="
READ(*,*) A
WRITE(6,*) "Valor de A = ", A
END
Figura 5.1 Programa5a.f90.
enter.
c) Na terceira linha, o comentrio Valor de A = e o valor da varivel A, resultado do comando
WRITE(6,*) "Valor de A = ", A do programa. Deve-se notar que foi fornecido um valor
inteiro para a varivel A, no caso 1. Mas o resultado do programa mostra o valor 1.000000
porque a varivel A do tipo real.

d) Na quarta linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer
9) O resultado da execuo do programa5a.f90 exatamente igual a do programa3c.f90, da seo 3.1 do
captulo 3. Conforme explicado no item 5a, acima, isso ocorre devido equivalncia completa entre
os comandos WRITE(*,*) e WRITE(6,*).
Figura 5.2 Resultado da execuo do programa5a.f90.
5.2 programa5b.f90
Fortran:
projeto chamado programa05 o programa-fonte programa5b.f90

REAL A
READ(*,*) A
OPEN(7, file="saida5b.txt")
CLOSE(7)
END

a) No programa5b.f90 so usados dois novos comandos do FORTRAN: OPEN e CLOSE. Ambos
devem ser usados em conjunto.
b) A forma do comando OPEN que ser usada neste texto OPEN(nmero, file=nome). O
comando OPEN usado para: definir um nmero que ser usado como referncia a um arquivo; e
para abrir o arquivo chamado nome. O nmero pode ser de 1 a 99 e 105 a 299. A utilizao
deste nmero num comando WRITE(nmero,*) resulta na escrita de comentrios ou variveis no
arquivo que corresponde ao nmero definido no comando OPEN. O nome do arquivo pode ser
qualquer um mas deve ficar entre aspas. Quando se declara um nome de arquivo num comando
OPEN, se o arquivo no existir, ele criado dentro do diretrio do projeto.
c) A forma do comando CLOSE que ser usada neste texto CLOSE(nmero). O comando CLOSE
usado para fechar ou encerrar o uso de um arquivo aberto anteriormente com o comando OPEN.
d) Todos arquivos abertos com o comando OPEN so fechados ao final da execuo do programa,
existindo ou no o comando CLOSE.
e) Dentro de um programa, para um mesmo nmero ou arquivo, a seqncia obrigatria dos
comandos a seguinte: OPEN, WRITE, CLOSE. Para um mesmo arquivo, deve existir apenas um
comando OPEN e um CLOSE dentro do programa, e podem existir diversos comandos WRITE.
f) Podem ser usados vrios arquivos simultaneamente num programa.
g) A principal vantagem de se usar um arquivo ter um registro permanente dos resultados do
programa para posterior anlise. Isso fica mais evidente quanto maior for a quantidade de
resultados de um programa.
7) Ao se executar o programa, atravs de Build, Execute, surge uma janela do DOS, mostrada na
Figura 5.3, dentro da qual tem-se:
Figura 5.3 Resultado da execuo do programa5b.f90 na janela DOS com A = 1.
a) Na primeira linha, o comentrio Entre com o valor de A =, resultado do comando WRITE(*,*)

b) Na segunda linha, o programa pra e fica aguardando que seja fornecido o contedo da varivel A,

enter.
c) Em seguida ocorrer a criao do arquivo saida5b.txt, dentro do diretrio do projeto, como
resultado do comando OPEN(7, file="saida5b.txt") do programa, uma vez que este arquivo
ainda no existe quando o programa5b.f90 for executado pela primeira vez. Este comando
tambm declara que ser usado o nmero 7 no programa como referncia ao arquivo saida5b.txt.
d) Conforme mostrado na Figura 5.4, na primeira linha do arquivo saida5b.txt est escrito o
comentrio Valor de A = e o valor da varivel real A como resultado do comando WRITE(7,*)
"Valor de A = ", A do programa.
e) O arquivo saida5b.txt fechado, isto , nada mais pode ser escrito nele aps o comando CLOSE(7)
do programa.
Figura 5.4 Resultado da execuo do programa5b.f90 no arquivo saida5b.txt com A = 1.
8) A existncia do arquivo saida5b.txt pode ser comprovada ao se executar Start, Programs, Windows
NT Explorer. Em seguida, indicar o diretrio do projeto, no caso, programa05. Finalmente, ao se
clicar duas vezes sobre o nome do arquivo, ele ser aberto, podendo-se ver o seu contedo.
9) Executar novamente o programa, atravs 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, necessrio gravar os resultados em arquivos
diferentes a cada execuo 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 contedo do arquivo saida5b.txt.
10) No comando OPEN tambm possvel especificar todo o caminho ou o diretrio aonde o arquivo
deve ser criado ou aberto. Quando o diretrio no especificado, por default, usa-se o diretrio do
projeto ou o diretrio 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
novamente o programa5b.f90, gerar o seu executvel, executar o programa. Usar o aplicativo

Windows NT Explorer para encontrar e abrir o arquivo saida5b.txt, que agora dever estar no
diretrio C:\Temp.
Figura 5.5 Resultado da execuo do programa5b.f90 no arquivo saida5b.txt com A = 123.
11) Na prxima seo, apresentada uma forma de se automatizar a abertura do arquivo de sada. Isso
permite maior rapidez na visualizao dos resultados de um programa.
5.3 programa5c.f90
Fortran:
a) No programa5c.f90 so 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 substitudo pelo nome da biblioteca desejada. Uma biblioteca, no presente
contexto, uma coleo de comandos que no 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, no. Para ele ser
usado necessrio 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 prprias bibliotecas, como
ser visto nos captulos avanados deste texto.

USE PORTLIB
REAL A
INTEGER VER

READ(*,*) A
OPEN(7, file="saida5c.txt")
CLOSE(7)
VER = SYSTEM ("Notepad saida5c.txt")
END
d) No editor do aplicativo Fortran, o comando SYSTEM no fica na cor azul por no ser um dos
comandos bsicos da linguagem FORTRAN. O comando SYSTEM utilizado para executar
comandos que interagem com o sistema operacional Windows. Isso permite que, durante a
execuo do programa escrito em FORTRAN, seja realizado o seguinte: executar outros
programas ou aplicativos; criar ou deletar diretrios ou arquivos; e qualquer outro comando
possvel de se executar numa janela do tipo DOS. Para utilizar o comando SYSTEM deve-se
definir uma varivel do tipo inteiro. Depois, usar esta varivel na linha do programa aonde se
deseja executar o comando SYSTEM. Dentro de parnteses e aspas, deve-se incluir a seqncia
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 varivel VER, usada
nesta linha, foi definida como uma varivel do tipo inteiro na linha INTEGER VER do programa.
7) Ao se executar o programa, atravs de Build, Execute, ocorrer exatamente o mesmo j explicado na
seo anterior para o programa5b.f90. A nica diferena que quase no final da execuo do
programa, o arquivo de resultados, que foi denominado de saida5c.txt, ser aberto automaticamente
pelo aplicativo Notepad para mostrar o seu contedo. Ao se fechar o Notepad, a execuo do
programa5c.f90 ser encerrada.
8) No caso do comando OPEN ser usado para especificar todo o caminho ou o diretrio aonde o arquivo
deve ser criado ou aberto, o comando SYSTEM tambm deve ser adaptado. Por exemplo, se o arquivo

saida5c.txt for criado no diretrio C:\Temp com o comando OPEN(7,
file="C:\Temp\saida5c.txt"), o comando correspondente para abrir automaticamente o arquivo

saida5c.txt VER = SYSTEM ("Notepad C:\Temp\saida5c.txt").
5.4 programa5d.f90
1) Nesta seo ser usado o mesmo projeto da seo anterior deste captulo. Portanto, deve-se executar o
seguinte no Fortran:
a) Conforme pode-se ver na Figura 5.6, ABS, LOG10, ACOS, COS e COSH esto escritos em azul
dentro do Fortran. Elas so chamadas de funes intrnsecas do FORTRAN, ou seja, so funes
ou comandos que existem dentro da linguagem FORTRAN. Elas so funes matemticas usadas
em clculos que envolvem variveis do tipo real. Outras funes so apresentadas nas Tabelas
5.5 e 5.6.
b) A lista completa de funes matemticas intrnsecas 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 smbolo ?InfoView; e acessar as opes Reference, Procedures, Numeric Procedures e
as opes Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic
Procedures.
a) Na primeira linha, o comentrio Entre com o valor de A =, resultado do comando WRITE(*,*)
enter.
c) Em seguida ocorrer a criao do arquivo saida5d.txt, dentro do diretrio do projeto, como
resultado do comando OPEN(8, file="saida5d.txt") do programa, uma vez que este arquivo
ainda no existe quando o programa5d.f90 for executado pela primeira vez. Este comando
tambm declara que ser usado o nmero 8 no programa como referncia ao arquivo saida5d.txt.
d) Os resultados das funes aplicadas no programa5d.f90 so mostrados na Figura 5.8.

USE PORTLIB
REAL A, B, C, Pi
INTEGER VER

READ(*,*) A
OPEN(8, file="saida5d.txt")
B = ABS(A)
WRITE(8,*) "B = Mdulo 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 hiperblico de Pi =", D
CLOSE(8)
VER = SYSTEM ("Notepad saida5d.txt")
END
8) Comparar cada resultado mostrado na Figura 5.8 com o resultado obtido de uma calculadora.

9) Executar novamente o programa com outro valor para a varivel A. Comparar cada novo resultado
com o obtido de uma calculadora.
10) Os programas-executveis tambm podem ser executados, rodados ou postos para funcionar fora do
aplicativo Fortran. Para testar isso, primeiro, fechar o aplicativo Fortran. Em seguida, utilizando o
aplicativo Windows NT Explorer, copiar o programa-executvel chamado programa05.exe ou
programa05.application para o diretrio C:\Temp. Para executar o programa, basta clicar duas
vezes sobre o arquivo copiado. Como resultado, surgir o arquivo saida5d.txt. O diretrio C:\Temp
apenas um exemplo. O programa-executvel pode ser copiado para qualquer outro diretrio e ser
executado l.
Figura 5.6 Programa5d.f90.

Tabela 5.5 Algumas funes matemticas do FORTRAN.
Funo Comando Observao
Mdulo ou valor absoluto Y = ABS(X)
Raiz quadrada Y = SQRT(X)
Exponencial: Y = eX Y = EXP(X)
Logaritmo natural Y = LOG(X)

Logaritmo decimal Y = LOG10(X)
Sinal Y = SIGN(X,Z) Y = valor absoluto de X vezes o sinal de Z
Mnimo Y = MIN(X,Z,W) Y = valor mnimo entre X, Z e W; o
argumento pode conter 2 ou mais variveis
Mximo Y = MAX(X,Z,W) Y = valor mximo entre X, Z e W; o
Tabela 5.6 Algumas funes trigonomtricas do FORTRAN.

Seno Y = SIN(X) X em radianos
Cosseno Y = COS(X) X em radianos
Tangente Y = TAN(X) X em radianos
Arco-seno Y = ASIN(X) Y em radianos
Arco-cosseno Y = ACOS(X) Y em radianos
Arco-tangente Y = ATAN(X) Y em radianos
Seno hiperblico Y = SINH(X)
Cosseno hiperblico Y = COSH(X)
Tangente hiperblica Y = TANH(X)
Figura 5.7 Janela DOS do programa5d.f90.

Figura 5.8 Arquivo saida5d.txt do programa5d.f90.
5.5 EXERCCIOS
Exerccio 5.1
a) ler o primeiro valor (real) de uma progresso aritmtica (P.A.), denotado por A1
b) ler a diferena (nmero real) entre dois termos subseqentes da P.A., denotada por D
d) calcular o valor (real) do ltimo termo da P.A., denotado por AN
f) escrever no arquivo chamado saida_5p1.txt os trs valores lidos e os dois calculados juntamente
com comentrios para identific-los
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.
Exerccio 5.2
a) ler algumas variveis do tipo real
b) aplicar as funes matemticas da Tabela 5.5 sobre as variveis lidas
c) escrever no arquivo chamado saida_5p2.txt os valores lidos e os resultados calculados com as
funes juntamente com comentrios para identific-los
4) Executar o programa. Em seguida, comparar os resultados escritos com aqueles obtidos de uma
calculadora.

Exerccio 5.3
a) ler algumas variveis do tipo real
b) aplicar as funes matemticas da Tabela 5.6 sobre as variveis lidas
c) escrever no arquivo chamado saida_5p3.txt os valores lidos e os resultados calculados com as
funes juntamente com comentrios para identific-los
4) Executar o programa. Em seguida, comparar os resultados escritos com aqueles obtidos de uma
calculadora.

Captulo 6. FORMATOS DE EDIO
Conceitos e comandos de formatos de edio para variveis do tipo inteiro, caracter e real
Regras de edio de programas-fonte em FORTRAN
Seqncia obrigatria dos comandos dentro de programas-fonte em FORTRAN
Comandos do FORTRAN: WRITE(nmero,nmero) e FORMAT
6.1 FORMATOS DE EDIO PARA VARIVEIS DO TIPO CARACTER: programa6a.f90

1) Para acessar o programa Fortran, no Windows: Start, Programs, Fortran PowerStation 4.0,
Microsoft Developer Studio
2) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa06
3) No Fortran, seguindo o procedimento-padro, criar e inserir no projeto o programa-fonte
programa6a.f90
Captulo 6. Formatos de edio 68

USE PORTLIB CHARACTER(10) A, B

CHARACTER(20) C
INTEGER VER
WRITE(*,*) "Variaveis do tipo caracter"

WRITE(*,*) "Entre com os conteudos de A e B"
READ(*,*) A, B
C = A // B
OPEN(9, file="saida6a.txt") WRITE(9,*) A, "= A sem formato"

WRITE(9,21) A
21 FORMAT ( A2, "= A no formato A2" )
WRITE(9,22) A
WRITE(9,23) A
WRITE(9,24) A
24 FORMAT("10X", 10X, "Contedo de A =", A10, 1/)
WRITE(9,25) A
25 FORMAT("T10", T10, "Contedo 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), "= variveis A e B no formato 2(A10)" )
CLOSE(9)
VER = SYSTEM("Notepad saida6a.txt")
END

a) O objetivo do programa6a.f90 explicar alguns formatos de edio utilizados com variveis do
tipo caracter.
b) No captulo 5, alm de um asterisco, o comando WRITE foi utilizado com um nmero para
identificar o local (janela ou arquivo) onde seria escrito algo, isto , ele foi usado na forma
WRITE(nmero1,*). Um exemplo a linha WRITE(9,*) A, "= A sem formato" do programa.
Agora, no programa6a.f90, o comando WRITE utilizado com dois nmeros, ou seja, na forma
WRITE(nmero1,nmero2), por exemplo, a linha WRITE(9,21) A do programa. O nmero2 est
associado a um novo comando do FORTRAN chamado de FORMAT.
c) O comando FORMAT usado para especificar o formato com que comentrios e contedos
(strings ou nmeros) de variveis so escritos numa janela ou num arquivo. Tambm usado na
leitura de dados.
d) A sintaxe, isto , a forma com que se deve usar o comando FORMAT : nmero2 FORMAT
(formatos). O nmero2 deve ser o mesmo utilizado no comando WRITE. Dentro de parnteses,
deve-se especificar os formatos de edio que sero usados, separados por vrgula. Um exemplo
a linha 21 FORMAT ( A2, "= A no formato A2" ) do programa, que especifica o formato A2
para escrever a varivel A, do tipo caracter, chamada na linha WRITE(9,21) A do programa.
e) Os comandos FORMAT podem ser includos em qualquer lugar dentro do programa-fonte, desde
que seja abaixo de comandos USE e acima do comando END. Eles podem ser aglomerados num
nico lugar ou cada um pode estar abaixo ou acima do seu respectivo comando WRITE. No
necessrio seguir qualquer ordenamento para os nmeros usados nos comandos FORMAT, nem
para suas posies relativas dentro do programa-fonte. E no existe qualquer relao entre os
nmeros usados em comandos OPEN e os nmeros usados nos comandos FORMAT. Eles at
podem ser iguais.
f) Cada tipo de varivel (caracter, inteiro ou real) tem identificadores especiais para escrever seu
contedo na forma desejada. Alm disso, existem identificadores que facilitam a escrita de
comentrios e da forma ou disposio esttica com que se escreve algo.
g) O identificador de variveis do tipo caracter a letra A seguida de um nmero que especifica a
quantidade mxima de caracteres para escrever cada varivel. Dentro deste espao, o contedo de
cada varivel do tipo caracter escrito da esquerda para a direita. Se o contedo da varivel ocupa
mais espao do que o reservado para escrev-la, a parte excedente no escrita, desconsiderada.
Um exemplo de uso deste identificador A2, citado no item d, acima. Neste caso, reservou-se
duas colunas ou caracteres para escrever uma varivel do tipo caracter.
h) Dentro de um comando FORMAT, isto , entre parnteses, pode-se escrever um ou mais
comentrios, cada um devendo ficar entre aspas, como na linha 22 FORMAT ( A5, "= A no
formato A5" ) do programa.
i) O identificador X usado para deixar espaos em branco entre dois formatos de edio. Ele
usado na forma NX, onde N um nmero que representa a quantidade de espaos em branco. Um
exemplo a linha 24 FORMAT("10X", 10X, "Contedo de A =", A10, 1/) do programa,
onde usou-se o formato 10X.
j) Nesta mesma linha do programa h o formato de edio N/, onde N um nmero que representa a
quantidade de linhas que o cursor descer quando encontrar este formato. Neste caso, uma linha,
devido ao formato 1/.
k) O identificador T, de tabulao, usado para se escrever algo a partir de uma coluna especfica,
onde a coluna 1 fica na margem esquerda. Ele usado na forma TN, onde N o nmero da coluna
a partir da qual se escrever algo que vem a seguir dentro de um comando FORMAT. Um
exemplo a linha 25 FORMAT("T10", T10, "Contedo de A =", A10, 1/) do programa,
onde usou-se o formato T10.
l) Pode-se usar um nico comando WRITE, com seu respectivo comando FORMAT, para se
escrever diversas variveis. Neste caso, cada varivel ser escrita com o formato que estiver na
mesma seqncia dos comandos WRITE e FORMAT. Por exemplo, na linha WRITE(9,10) A, B,
C do programa, escreve-se as variveis A, B e C com o formato nmero 10, que corresponde
linha 10 FORMAT(5X, "A =", A10, 1/, 5X, "B =", A10, 1/, 5X, "C =", A20, 2/) do
programa. Portanto, a primeira varivel (A) ser escrita com o formato A10, que o primeiro
formato de edio de variveis que aparece no comando FORMAT. E as variveis B e C sero
escritas com os formatos A10 e A20, respectivamente, que so o segundo e o terceiro formatos de
variveis no comando FORMAT.
m) O comando FORMAT identificado pelo nmero 10 no programa tem exatamente a mesma funo
que o comando FORMAT identificado pelo nmero 11. A nica diferena na edio do
programa-fonte. No 10 FORMAT, todos os formatos de edio usam apenas uma linha do
programa-fonte. J no 11 FORMAT, so usadas trs linhas. Neste caso, quando um mesmo
comando precisa ou se quer empregar mais de uma linha por motivos estticos, usa-se o smbolo
&, 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 nmero de caracteres
reservados para se escrever uma varivel do tipo caracter. Por exemplo, na linha 12 FORMAT (
2(A10), "= variveis A e B no formato 2(A10)" ) do programa usa-se duas vezes o
formato A10 para se escrever duas variveis do tipo caracter.
8) Ao se executar o programa, atravs de Build, Execute, surge uma janela do DOS, mostrada na Figura
6.1, dentro da qual tem-se:
a) Na primeira linha, o comentrio Variaveis do tipo caracter, resultado do comando WRITE(*,*)
"Variaveis do tipo caracter" do programa.
b) Na segunda linha, o comentrio Entre com os conteudos de A e B, resultado do comando
WRITE(*,*) "Entre com os conteudos de A e B" do programa.
c) Na terceira linha, o programa pra e fica aguardando que sejam fornecidos os contedos das
variveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa
continue sua execuo necessrio digitar Rio 45, Teste, por exemplo, e, em seguida, clicar
na tecla enter.
d) Em seguida ocorrer a criao do arquivo saida6a.txt, dentro do diretrio do projeto, como
resultado do comando OPEN(9, file="saida6a.txt") do programa, uma vez que este arquivo
ainda no existe quando o programa6a.f90 for executado pela primeira vez. Este comando tambm
declara que ser usado o nmero 9 no programa como referncia ao arquivo saida6a.txt.
e) Como resultado da linha VER = SYSTEM("Notepad saida6a.txt") do programa, o aplicativo
Notepad abre automaticamente o arquivo saida6a.txt cujo contedo mostrado na Figura 6.2. Na
segunda e terceira linha do arquivo saida6a.txt o contedo da varivel A (Rio 45) foi cortado
parcialmente devido aos poucos caracteres usados para escrev-la, no caso 2 e 5, definidos por A2
e A5. Para evitar este tipo de problema, sempre se deve superdimensionar o espao para escrever
o contedo de cada varivel.
Figura 6.1 Janela DOS do programa6a.f90.

Figura 6.2 Arquivo saida6a.txt do programa6a.f90.
9) At entender, comparar o resultado de cada comando WRITE, e seu respectivo comando FORMAT
no programa6a.f90, mostrado em cada linha da Figura 6.2 ou no arquivo saida6a.txt.
10) Executar novamente o programa com outros contedos para as variveis A e B. Analisar os novos
resultados.
6.2 FORMATOS DE EDIO PARA VARIVEIS DO TIPO INTEIRO: programa6b.f90
Fortran:
programa6b.f90

USE PORTLIB INTEGER A, B, C

INTEGER VER
WRITE(*,*) "Variaveis do tipo inteiro"
WRITE(*,*) "Entre com os valores de A e B"
READ(*,*) A, B
C = A + B
OPEN(9, file="saida6b.txt")
WRITE(9,*) A, "= A sem formato"

WRITE(9,21) A
WRITE(9,22) A
WRITE(9,23) A
WRITE(9,24) A
WRITE(9,25) A
WRITE(9,10) A, B, C
WRITE(9,11) A, B, C
WRITE(9,9) A, B, C CLOSE(9)
VER = SYSTEM("Notepad saida6b.txt")
21 FORMAT ( I2, "= A no formato I2" )

24 FORMAT("10X", 10X, "Valor de A =", I10, 1/)
25 FORMAT("T10", T10, "Valor de A =", I10, 1/)
10 FORMAT(5X, "A =", I10, 1/, 5X, "B =", I10, 1/, 5X, "C =", I10, 2/)
11 FORMAT( 5X, "A =", I10, 1/, &
5X, "B =", I10, 1/, &
5X, "C =", I10, 2/ )
9 FORMAT ( 3(I10), "= variveis A, B e C no formato 3(I10)" )
END

a) O objetivo do programa6b.f90 explicar alguns formatos de edio utilizados com variveis do
tipo inteiro.
b) No caso do programa6b.f90, os comandos FORMAT foram todos aglomerados no final do
programa-fonte, na mesma ordem de seus respectivos comandos WRITE.
c) O identificador de variveis do tipo inteiro a letra I seguida de um nmero que especifica a
quantidade mxima de algarismos ou colunas para escrever cada varivel. Dentro deste espao, o
contedo de cada varivel do tipo inteiro escrito da direita para a esquerda. Uma coluna usada
para o sinal do nmero inteiro. Se o valor inteiro da varivel ocupar mais espao, colunas ou
algarismos do que o reservado para escrev-la, no lugar do nmero sero apresentados apenas
asteriscos. Isso significa que o formato utilizado incompatvel com o valor da varivel. Um
exemplo de uso deste identificador I5 na linha 22 FORMAT ( I5, "= A no formato I5" ) do
programa.
d) Os identificadores X, para espaos em branco, T, para tabulao, e N/, para o cursor descer N
linhas, explicados na seo 6.1 para variveis do tipo caracter, tambm se aplicam com variveis
do tipo inteiro, conforme pode-se ver no programa6b.f90.
e) O formato M(IN) equivalente a M vezes o formato IN, onde N o nmero de colunas ou
algarismos reservados para se escrever uma varivel do tipo inteiro. Por exemplo, na linha 9
FORMAT ( 3(I10), "= variveis A, B e C no formato 3(I10)" ) do programa usa-se trs
vezes o formato I10 para se escrever trs variveis do tipo inteiro.
a) Na primeira linha, o comentrio Variaveis do tipo inteiro, resultado do comando WRITE(*,*)
"Variaveis do tipo inteiro" do programa.
b) Na segunda linha, o comentrio Entre com os valores de A e B, resultado do comando
WRITE(*,*) "Entre com os valores de A e B" do programa.
c) Na terceira linha, o programa pra e fica aguardando que sejam fornecidos os valores das
continue sua execuo necessrio digitar 111 222, por exemplo, e, em seguida, clicar na tecla
enter.
d) Em seguida ocorrer a criao do arquivo saida6b.txt, dentro do diretrio do projeto, como
resultado do comando OPEN(9, file="saida6b.txt") do programa, uma vez que este arquivo
ainda no existe quando o programa6b.f90 for executado pela primeira vez. Este comando
tambm declara que ser usado o nmero 9 no programa como referncia 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 contedo mostrado na Figura 6.4. Na
segunda linha do arquivo saida6b.txt o valor da varivel A (111) foi trocado por dois asteriscos.
Isso ocorre porque o formato usado (I2) incompatvel para se escrever o valor da varivel A, que
neste caso precisa de pelo menos trs colunas, ou seja, o formato mnimo seria I3. Para evitar este
tipo de problema, sempre se deve superdimensionar o espao para escrever o valor de cada
varivel.
Figura 6.3 Janela DOS do programa6b.f90.
no programa6b.f90, mostrado em cada linha da Figura 6.4 ou no arquivo saida6b.txt.
9) Executar novamente o programa com outros valores para as variveis A e B. Analisar os novos
resultados.
Figura 6.4 Arquivo saida6b.txt do programa6b.f90.
6.3 FORMATOS DE EDIO PARA VARIVEIS DO TIPO REAL: programa6c.f90
Fortran:
programa6c.f90
a) O objetivo do programa6c.f90 explicar alguns formatos de edio utilizados com variveis do tipo
real.
b) No caso do programa6c.f90, os comandos FORMAT foram todos aglomerados no incio do
programa-fonte, antes mesmo de seus respectivos comandos WRITE.
c) Os dois principais identificadores de variveis do tipo real so representados pelas letras F e E.
d) O formato de ponto flutuante usado para nmeros reais. Ele denotado por FX.Y, onde Y um
nmero que equivale quantidade de algarismos usados para representar a parte decimal do valor
da varivel. X um nmero que equivale quantidade total de colunas usadas para representar o
valor da varivel, incluindo seu sinal, o ponto decimal e a parte decimal. O nmero X sempre tem
que ser maior do que Y. No programa, por exemplo, so usados os formatos F5.2 e F5.0.

USE PORTLIB
REAL A, B, C
INTEGER VER

11 FORMAT( 5X, "A =", 1PE15.3, 1/, &
5X, "B =", 1PE15.3, 1/, &
5X, "C =", 1PE15.3, 1/ )
12 FORMAT ( 3(1PE15.3), "= variveis A, B e C no formato 3(1PE15.3)" )
21 FORMAT ("A no formato F5.2 =", F5.2, 1/,
& "A no formato F5.0 =", F5.0,
1/, & "A no formato E15.3 =", E15.3,
1/, & "A no formato 1PE15.3 =",
1PE15.3, 1/ )
WRITE(*,*) "Variaveis do tipo real"

WRITE(*,*) "Entre com os valores de A e
B" READ(*,*) A, B
C = A + B
OPEN(9, file="saida6c.txt")
WRITE(9,*) A, "= A sem
formato"
WRITE(9,21) A, A, A, A
WRITE(9,11) A, B, C
WRITE(9,12) A, B, C
CLOSE(9)
VER = SYSTEM("Notepad
saida6c.txt") END
e) O formato exponencial tambm usado para nmeros reais. Ele denotado por EX.Y, onde Y um
nmero que equivale quantidade de algarismos usados para representar a parte decimal do valor
da varivel. X um nmero que equivale quantidade total de colunas usadas para representar o
valor da varivel, incluindo seu sinal, o ponto decimal, a parte decimal, a letra E, o sinal do
expoente e dois algarismos para o valor do expoente. O nmero X sempre tem que ser maior do que
Y. No programa, por exemplo, usado o formato E15.3.
f) No formato EX.Y, nenhum algarismo usado na parte inteira. Para que seja usado um algarismo na
parte inteira do nmero real, pode-se usar o formato 1PEX.Y. No programa, por exemplo, usado o
formato 1PE15.3.
g) Dentro das X colunas dos formatos FX.Y, EX.Y e 1PEX.Y, o contedo de cada varivel do tipo
real escrito da direita para a esquerda. Os valores de X e Y so definidos pelo programador.
h) Os identificadores X, para espaos em branco, T, para tabulao, e N/, para o cursor descer N
linhas, explicados na seo 6.1 para variveis do tipo caracter, tambm se aplicam com variveis do
tipo real, conforme pode-se ver no programa6c.f90.
i) O formato M(1PEX.Y) equivalente a M vezes o formato 1PEX.Y. Por exemplo, na linha 12
FORMAT ( 3(1PE15.3), "= variveis A, B e C no formato 3(1PE15.3)" ) do programa
usa-se trs vezes o formato 1PE15.3 para se escrever trs variveis do tipo real.
a) Na primeira linha, o comentrio Variaveis do tipo real, resultado do comando WRITE(*,*)
"Variaveis do tipo real" do programa.
b) Na segunda linha, o comentrio Entre com os valores de A e B, resultado do comando
continue sua execuo necessrio digitar 1.234 2.22, por exemplo, e, em seguida, clicar na
tecla enter.
d) Em seguida ocorrer a criao do arquivo saida6c.txt, dentro do diretrio do projeto, como
resultado do comando OPEN(9, file="saida6c.txt") do programa, uma vez que este arquivo
ainda no existe quando o programa6c.f90 for executado pela primeira vez. Este comando tambm
declara que ser usado o nmero 9 no programa como referncia 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 contedo mostrado na Figura 6.6.
Dependendo do formato empregado, alguns algarismos do nmero real so truncados, como se
pode ver da segunda quarta linha do arquivo saida6c.txt.
Figura 6.5 Janela DOS do programa6c.f90.

Figura 6.6 Arquivo saida6c.txt do programa6c.f90.
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 variveis A e B. Analisar os novos
resultados.
10) Num mesmo comando FORMAT, podem ser usados identificados de variveis do tipo inteiro,
caracter e real, alm de comentrios, e dos formatos NX, N/ e TN.
6.4 RESUMO DE REGRAS GERAIS DE EDIO DE PROGRAMAS EM FORTRAN
1) Em cada linha do programa, tudo que estiver aps o smbolo de exclamao (!) no executado pelo
programa. Serve apenas como comentrio usado para esclarecer o que faz cada parte do programa.
Dentro do Fortran PowerStation 4.0, todos os comentrios ficam na cor verde. Linhas em branco so
equivalentes a ter o smbolo (!) de comentrio 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.
3) Todos os comandos intrnsecos da linguagem FORTRAN ficam na cor azul dentro do Fortran
PowerStation 4.0.
4) O smbolo & usado ao final de uma linha de programa para indicar que o comando iniciado numa
linha contnua na linha seguinte.
5) Cada linha de programa pode usar at 132 colunas, incluindo os espaos em branco.
6) Em geral, espaos em branco tm apenas funo esttica no programa, no afetando os comandos ou
as instrues do programador. Os espaos em branco so considerados quando usados dentro de
comentrios nos comandos WRITE e FORMAT.
7) Nos comandos da linguagem FORTRAN e em nomes de variveis, no existe distino entre letras
maisculas ou minsculas. Por exemplo, WRITE, write, Write e wRiTe so equivalentes. A distino
entre letras minsculas e maisculas existe dentro de comentrios nos comandos WRITE e FORMAT.

8) Na linguagem FORTRAN, os nomes de variveis podem ter at 31 caracteres que incluem
combinaes das 26 letras do alfabeto, dos algarismos 0, 1, 2, 3 a 9, e o trao de sublinhado. No
permitido acentuao e todas as variveis devem comear por uma letra. Exemplos de nomes de
variveis (separadas por vrgula): v, va, variavel, variavel_2, variavel_31, nome03, nome_03,
nome_da_rua.
6.5 SEQNCIA OBRIGATRIA DE COMANDOS EM FORTRAN
At este captulo foram vistos comandos da linguagem FORTRAN que podem ser divididos em
cinco tipos:
1) Comando para incluso de biblioteca no programa-fonte: USE
2) Comandos para declarar tipos de variveis: INTEGER, REAL e CHARACTER
3) Outros comandos intrnsecos (WRITE, READ, OPEN, CLOSE) ou no do FORTRAN (SYSTEM),
funes intrnsecas (LOG, TRIM etc) e qualquer outro comando criado pelo programador, por
exemplo, clculos e operaes com strings
4) Comando de encerramento do programa-fonte: END
5) Comando de edio: FORMAT
Se todos os cinco tipos de comandos forem usados simultaneamente num programa-fonte, a
seqncia obrigatria 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
especfico a seqncia obrigatria : OPEN, WRITE e outros comandos, CLOSE.
Encerrar a sesso seguindo o procedimento-padro.
6.6 EXERCCIOS
Exerccio 6.1
Editar um programa-fonte em FORTRAN para realizar um clculo de interpolao linear executando o
seguinte algoritmo (passos):
1) Ler os valores de duas variveis do tipo real, chamadas X1 e X2, que correspondem a dois dados
tabelados de uma varivel independente
2) Ler os valores de duas variveis do tipo real, chamadas Y1 e Y2, que correspondem a dois dados
tabelados de uma varivel dependente de X
3) Ler o valor de uma varivel do tipo real, chamada X, para o qual se deseja realizar a interpolao
4) Calcular o valor da varivel Y, em funo do valor de X, usando interpolao linear
5) Utilizando comandos FORMAT, escrever no arquivo chamado saida_6p1.txt os cinco valores lidos e
o resultado de Y, juntamente com comentrios 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.
Exerccio 6.2
Editar um programa-fonte em FORTRAN para realizar clculos com uma progresso geomtrica (P.G.)
executando o seguinte algoritmo (passos):
1) Ler o primeiro valor (real) da P.G., denotado por a1
2) Ler a razo (nmero real) entre dois termos subseqentes da P.G., denotada por q
3) Ler o nmero (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 trs valores lidos e os
dois calculados, juntamente com comentrios 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.

Captulo 7. DECISES E OPES
Conceitos de: deciso, condio, operadores relacionais e lgicos, e opo
Comandos do FORTRAN: IF THEN ELSE END IF, SELECT CASE CASE END SELECT
7.1 programa7a.f90

programa7a.f90
a) Nesta e na prxima seo so vistas trs formas de uso do comando IF (SE). A primeira
mostrada na Tabela 7.2 e usada em diversas linhas do programa7a.f90. O comando IF usado
para tomar decises com base em condies. Se as condies so satisfeitas, executa-se o
comando que est na mesma linha do IF, caso contrrio, no.
b) Por exemplo, na linha IF ( A < B ) WRITE(*,*) "A eh MENOR do que B" do programa, se o
valor de A for menor do que o valor de B, executado o comando que est aps o parnteses, no
caso, escrever um comentrio. Aquilo que est dentro de parnteses chamado de condio, que
pode ser simples ou composta. Para definir as condies, so usados os chamados operadores
relacionais (Tabela 7.3) e lgicos (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 condio composta. Cada condio simples unida pelos
operadores lgicos .AND. e .OR., que em portugus significam E e OU.
d) Nas condies, alm de variveis, podem ser usados diretamente valores ou expresses
envolvendo valores e variveis.
e) Nas demais linhas do programa, so testados todos os operadores relacionais e lgicos.
Captulo 7. Decises e opes 83


REAL A, B
WRITE(*,*) "Entre com os valores de A e B"

READ(*,*) A, B
IF ( A < B ) WRITE(*,*) "A eh MENOR do que B"
IF ( A <= B ) WRITE(*,*) "A eh MENOR OU IGUAL a B"
IF ( A > B ) WRITE(*,*) "A eh MAIOR do que B"
IF ( A >= B ) WRITE(*,*) "A eh MAIOR OU IGUAL a B"
IF ( A == B ) WRITE(*,*) "A eh IGUAL a B"
IF ( A /= B ) WRITE(*,*) "A eh DIFERENTE de B"
IF ( (A < 0) .AND. (B < 0) ) WRITE(*,*) "A E B sao numeros NEGATIVOS"
IF ( (A > 0) .AND. (B > 0) ) WRITE(*,*) "A E B sao numeros POSITIVOS"
IF ( (A > 0) .OR. (B > 0) ) WRITE(*,*) "A OU B eh um numero POSITIVO"
END
Tabela 7.2 Sintaxe 1 do comando IF.
IF ( condies ) COMANDO
onde condies representa uma ou vrias condies que devem ser satisfeitas para
que COMANDO seja executado.
a) Na primeira linha, o comentrio Entre com os valores de A e B, resultado do comando

b) Na segunda linha, o programa pra e fica aguardando que sejam fornecidos os valores das
continue sua execuo necessrio digitar 1.0 2.0, por exemplo, e, em seguida, clicar na tecla
enter.
c) Em seguida so apresentados os comentrios correspondentes aos comandos IF cujas condies
foram satisfeitas para os valores de A e B.
Tabela 7.3 Operadores relacionais do FORTRAN.

Operador Significado
< menor
<= menor ou igual
> maior
>= maior ou igual
== igual
/= diferente
Tabela 7.4 Operadores lgicos do FORTRAN.

Operador Significado
.AND. e
.OR. ou
Figura 7.1 Resultado do programa7a.f90 para A = 1.0 e B = 2.0.
9) At entender, comparar os resultados da execuo 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.

Figura 7.2 Resultado do programa7a.f90 para A = 1 e B = 1.
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.
Figura 7.3 Resultado do programa7a.f90 para A = 1 e B = 2.
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
Fortran:
programa7b.f90
a) Este programa foi escrito para extrair as duas razes de uma equao do 2o grau.

b) Nesta seo mostrada e testada a segunda forma de uso do comando IF (SE), cuja sintaxe
apresentada na Tabela 7.6 e usada no programa7b.f90. Esta estrutura do comando IF permite que,
se as condies so satisfeitas, sejam executados diversos comandos do programa escritos em
vrias linhas. Se as condies no so satisfeitas, so executados os comandos que esto entre o
comando ELSE e o END IF.

REAL A, B, C
REAL D, X1, X2
WRITE(*,*) "Entre com os valores de A, B e C, onde"

WRITE(*,*) "A*(X**2) + B*X + C = 0"
READ(*,*) A, B, C
D = (B**2) - 4.0 * A * C
IF ( D >= 0.0 ) THEN
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 no 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
(SENO), e entre o ELSE e o END IF, para que sejam facilmente visualizados os comandos que
so ou no executados. Um exemplo desta recomendao mostrado no programa7b.f90, na
Tabela 7.5.

e) As trs formas de uso do comando IF, mostradas nas Tabelas 7.2, 7.6 e 7.7, podem ser combinadas
entre si, cada uma podendo ser inserida dentro das estruturas das outras.
IF ( condies ) THEN
BLOCO 1 (uma ou vrias linhas de programa com comandos)
ELSE
BLOCO 2 (uma ou vrias linhas de programa com comandos)
END IF
que o bloco 1 seja executado;
se as condies no forem satisfeitas, o bloco 2 executado.
IF ( condies ) THEN
BLOCO (uma ou vrias linhas de programa com comandos)
END IF
que o bloco de linhas de programa seja executado.

a) Na primeira linha, o comentrio Entre com os valores de A, B e C, onde, resultado do comando
WRITE(*,*) "Entre com os valores de A, B e C, onde" do programa.
b) Na segunda linha, o comentrio A*(X**2) + B*X + C = 0, resultado do comando WRITE(*,*)
"A*(X**2) + B*X + C = 0" do programa.
variveis A, B e C, resultado do comando READ(*,*) A, B, C do programa. Para que o
programa continue sua execuo necessrio digitar 1 5 6, por exemplo, e, em seguida, clicar
na tecla enter.

d) Em seguida so apresentados os resultados correspondentes ao bloco do programa selecionado em
funo da condio testada no comando IF.
Figura 7.4 Resultado do programa7b.f90 para A = 1, B = 5 e C = 6.
8) At entender, comparar os resultados da execuo 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.
Figura 7.5 Resultado do programa7b.f90 para A = 1, B = 6 e C = 10.
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
Fortran:
programa7c.f90


INTEGER A
WRITE(*,*) "Entre com o valor inteiro de A"

READ(*,*) A
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

a) No programa7c.f90 usado um novo comando do FORTRAN: SELECT CASE. Este comando
empregado para escolher apenas uma opo entre vrias e executar o bloco de linhas ou comandos
do programa correspondente opo escolhida. A opo feita em funo de uma varivel do
tipo inteiro ou caracter, chamada de varivel seletora. Cada bloco pode conter uma ou vrias
linhas de programa. A sintaxe deste comando apresentada na Tabela 7.9.
b) O nmero de opes existentes depende de cada caso ou programa em particular.
c) A opo CASE DEFAULT executada se nenhuma das anteriores for satisfeita.

d) Recomenda-se identar, isto , deslocar para a direita cada opo (CASE) e cada bloco para que
sejam facilmente visualizados os comandos ligados a cada opo. Um exemplo desta
recomendao mostrado no programa7c.f90, na Tabela 7.8.
e) Deve-se notar que em todos os comandos WRITE no usado o valor da varivel A.
Tabela 7.9 Sintaxe do comando SELECT CASE.
SELECT CASE ( variavel )
CASE ( valor1 )
BLOCO 1
CASE ( valor2 )
BLOCO 2
CASE DEFAULT
BLOCO DEFAULT
END SELECT
onde valor representa um valor inteiro, alguns valores separados por vrgula ou,
ainda, um intervalo de valores separados por dois pontos;
apenas o bloco de comandos correspondente ao valor da varivel executado.
A varivel de seleo pode ser do tipo inteiro ou caracter. No caso de varivel
caracter, os valores devem ser strings entre aspas.

a) Na primeira linha, o comentrio Entre com o valor inteiro de A, resultado do comando
WRITE(*,*) "Entre com o valor inteiro de A" do programa.
enter.

c) Na terceira linha, mostrado um comentrio correspondente opo selecionada em funo do
valor da varivel A.
8) At entender, verificar se o resultado da execuo do programa7c.f90, mostrado na Figura 7.6, est
correto em funo do valor da varivel A e o comentrio correspondente opo selecionada.
9) Executar novamente o programa com A = 2. At entender, verificar se o novo resultado da execuo
do programa7c.f90 est correto em funo do valor da varivel A e o comentrio correspondente
opo selecionada.
10) Repetir o item 9 com A = 50.
11) Repetir o item 9 com A = 2345.
12) Repetir o item 9 com outro valor qualquer.
13) Encerrar a sesso seguindo o procedimento-padro.
Figura 7.6 Resultado do programa7c.f90 para A = 10.
7.4 EXERCCIOS
Exerccio 7.1
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores inteiros de trs variveis, denotadas por A, B e C
2) Determinar qual das variveis tem o menor e o maior valor
Exerccio 7.2
Alterar o programa7b.f90 para que no ocorra erro de execuo quando o usurio entrar com valor nulo
para a varivel A, e que seja calculado e escrito o valor da nica raiz deste caso.
Exerccio 7.3
Editar um programa-fonte em FORTRAN para calcular as razes de uma equao algbrica cbica.
Exerccio 7.4
1) Mostrar na tela uma lista com pelo menos 4 opes de clculo: 1 = mdulo de A; 2 = raiz quadrada de
A; 3 = exponencial de A; 4 = logaritmo de A
2) Ler o valor da opo de clculo desejada
3) Ler o valor real da varivel A
4) Calcular o resultado de A para a opo escolhida pelo usurio
5) Mostrar o resultado de A

Captulo 8. CICLOS
Conceito de ciclo
Comandos do FORTRAN: DO END DO, EXIT
8.1 programa8a.f90

programa8a.f90
Tabela 8.1 Programa8a.f90

INTEGER A
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
WRITE(*,*) "Valor de A depois do ciclo =", A
END
5) Neste programa so usados dois novos comandos do FORTRAN: DO e END DO, que definem um
ciclo. Ele so usados para executar vrias vezes uma ou mais linhas do programa. Explicaes gerais
sobre o seu funcionamento so apresentadas na prxima seo.
6) Executar Build, Compile para compilar o programa. 7) Gerar o programa-executvel fazendo Build,
Build.
Captulo 8. Ciclos 94
a) Na primeira linha, o valor corrente ou atual da varivel A na memria 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 dcima-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 varivel A muda a cada repetio do ciclo.
c) Na dcima-segunda linha, o programa escreve o valor da varivel A como resultado da linha
WRITE(*,*) "Valor de A depois do ciclo =", A , que j est fora do ciclo.
Figura 8.1 Resultado do programa8a.f90.
9) Explicaes gerais sobre o funcionamento de um ciclo em FORTRAN so apresentadas a seguir.
8.2 programa8b.f90
Fortran:
programa8b.f90
INTEGER A, INICIO, FIM, PASSO, B, C
WRITE(*,*) "Entre com os valores inteiros de A, INICIO, FIM e PASSO"

READ(*,*) A, INICIO, FIM, PASSO
WRITE(*,*) "Valor de A antes do ciclo =", A
B = (FIM - INICIO + PASSO) / PASSO
C = MAX ( B, 0 )
WRITE(*,*) "O ciclo deve ser executado", C, " vezes"
DO A = INICIO, FIM, PASSO

WRITE(*,*) "Valor de A dentro do ciclo =", A
END DO
END

a) Neste programa so usados dois novos comandos do FORTRAN: DO e END DO, que definem um
ciclo. A sintaxe deles, isto , a forma de utiliz-los mostrada na Tabela 8.3. Todas as linhas do
programa que esto entre os comandos DO e END DO so executadas diversas vezes.
b) A definio de um ciclo envolve quatro variveis do tipo inteiro: A, INICIO, FIM e PASSO. Os
nomes delas podem ser outros quaisquer. Quando a execuo do programa chega a um comando
DO, a seqncia a seguinte:
b.1) A varivel A assume o valor da varivel INICIO
b.2) Verifica-se se deve-se entrar ou no no ciclo em funo dos valores das variveis
INICIO, FIM e PASSO, conforme explicao do item c abaixo
b.3) No caso de se entrar no ciclo:
b.3.1) So executadas todas as linhas do programa at se chegar ao comando END
DO
b.3.2) Retorna-se linha do comando DO
b.3.3) O valor da varivel A passa a ser A = A + PASSO
b.3.4) Retorna-se ao item b.2 acima
b.4) No caso de no se entrar no ciclo, a execuo do programa passa diretamente linha
que estiver abaixo do comando END DO
Tabela 8.3 Sintaxe do comando DO.

BLOCO (uma ou vrias linhas de programa com comandos)
END DO
onde os valores das variveis INICIO, FIM e PASSO devem ter sido definidos antes da
execuo do programa chegar ao comando DO.
c) O nmero de execues (varivel C) do ciclo depende das variveis do tipo inteiro INICIO, FIM e
PASSO, calculado atravs de
FIM INICIO + PASSO

B = (8.1)
PASSO
C = MAX ( B, 0 ) (8.2)
onde o resultado da funo MAX(B,0) o maior valor entre a varivel 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 varivel PASSO pode ser positivo ou negativo; nulo, no. Portanto, pode-se ter um
ciclo cujo valor de A progressivo (PASSO > 0) ou regressivo (PASSO < 0). Se PASSO = 1, seu
valor no precisa ser declarado no comando DO.
e) O valor da varivel A no pode ser alterado nas linhas que esto entre os comando DO e END
DO. Se isso for feito, resultar num erro de compilao.
f) Recomenda-se identar, isto , deslocar para a direita todas as linhas do programa que esto entre
os comandos DO e END DO para que facilmente se perceba os comandos que compem o ciclo.
Exemplos desta recomendao so mostrados no programa8a.f90 (Tabela 8.1) e no
programa8b.f90 (Tabela 8.2).
a) Na primeira linha, o comentrio 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.
variveis A, INICIO, FIM e PASSO, resultado do comando READ(*,*) A, INICIO, FIM,
PASSO do programa. Para que o programa continue sua execuo necessrio digitar 20 1 10 1,
por exemplo, e, em seguida, clicar na tecla enter.
c) Em seguida so apresentados os resultados correspondentes execuo do programa.
Figura 8.2 Resultado do programa8b.f90 para A = 20, INICIO = 1, FIM = 10 e PASSO = 1.
8) At entender, analisar os resultados do programa8b.f90, mostrados na Figura 8.2, considerando cada

linha do programa-fonte e as explicaes descritas no item 4 acima. Deve-se notar que o ciclo do
programa8b.f90 idntico ao do programa8a.f90, Figura 8.1, devido aos valores usados para as
variveis 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 explicaes descritas no item 4 acima.
tem-se um ciclo regressivo, pois PASSO < 0. At entender, analisar os novos resultados, mostrados
tem-se um ciclo progressivo, pois PASSO > 0. At entender, analisar os novos resultados, mostrados
tem-se um ciclo regressivo, pois PASSO < 0. At entender, analisar os novos resultados, mostrados
8.3 programa8c.f90
Fortran:

programa8c.f90
a) No programa8c.f90 usado um novo comando do FORTRAN: EXIT. Este comando empregado
para que a execuo de um ciclo seja interrompida e a execuo do programa continue na linha
seguinte ao comando END DO.
b) No programa8c.f90 tambm exemplificado o uso da varivel A em operaes ou clculos dentro
de um ciclo. Conforme j foi mencionado, o valor de A no pode ser alterado por comandos
dentro do ciclo. Mas o valor que a varivel A assume a cada execuo do ciclo pode ser usado em
outros clculos ou variveis.
c) No caso, a varivel SOMA zerada antes do incio do ciclo. A cada execuo do ciclo, seu valor
alterado com o valor atual da varivel A. O mesmo ocorre com a varivel CUBO.

d) Quando a condio estipulada na linha IF ( SOMA > FIM ) EXIT do programa for satisfeita, o
comando EXIT ser executado. Em seguida, a execuo do programa transferida para a linha
WRITE(*,*) "Valor de A depois do ciclo =", A do programa, que a linha seguinte ao
comando END DO.

INTEGER A, INICIO, FIM, PASSO, SOMA, CUBO
WRITE(*,*) "Entre com os valores inteiros de INICIO, FIM e PASSO"

READ(*,*) INICIO, FIM, PASSO
SOMA = 0
CUBO = 0

SOMA = SOMA + A
CUBO = CUBO + A**3
WRITE(*,*) "A, SOMA, CUBO =", A, SOMA, CUBO
IF ( SOMA > FIM ) EXIT
END DO
END

a) Na primeira linha, o comentrio Entre com os valores inteiros de INICIO, FIM e PASSO,
resultado do comando WRITE(*,*) "Entre com os valores inteiros de INICIO, FIM e
PASSO" do programa.
variveis INICIO, FIM e PASSO, resultado do comando READ(*,*) INICIO, FIM, PASSO do
programa. Para que o programa continue sua execuo necessrio digitar 1 10 1, por exemplo,
e, em seguida, clicar na tecla enter.
c) Em seguida so apresentados os resultados correspondentes execuo do programa.

8) At entender, analisar os resultados do programa8c.f90, mostrados na Figura 8.7, considerando cada
linha do programa-fonte e as explicaes descritas no item 4 acima.
9) Executar novamente o programa com INICIO = 5, FIM = 5 e PASSO = 2. At entender, analisar
os novos resultados, mostrados na Figura 8.8, considerando cada linha do programa-fonte e as
explicaes descritas no item 4 acima.
Figura 8.7 Resultado do programa8c.f90 para INICIO = 1, FIM = 10 e PASSO = 1.
Figura 8.8 Resultado do programa8c.f90 para INICIO = 5, FIM = 5 e PASSO = 2.
8.4 EXERCCIOS
Exerccio 8.1
1) Ler o valor inteiro de uma varivel, denotada por N
2) Determinar se N um nmero primo
3) Mostrar o resultado, isto , se N um nmero primo ou no.
Exerccio 8.2
1) Ler o valor inteiro de uma varivel, denotada por N
2) Calcular o fatorial de N apenas para N 0
3) Mostrar o resultado do fatorial de N
Exerccio 8.3
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de
uma progresso aritmtica, cujo problema est definido no exerccio 5.1
Exerccio 8.4
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de
uma progresso geomtrica, cujo problema est definido no exerccio 6.2

Captulo 9. CONJUNTOS
Conceitos de: conjunto, elemento, alocao dinmica de memria
Comandos do FORTRAN: DIMENSION, ALLOCATABLE, ALLOCATE, MINVAL, MAXVAL,
SUM
9.1 programa9a.f90

programa9a.f90
5) Objetivos do programa:
a) Utilizar trs novos comandos do FORTRAN: DIMENSION, ALLOCATABLE e ALLOCATE
b) Determinar os valores mnimo e mximo e a mdia de um conjunto de variveis do tipo real
a) Todas as variveis do tipo inteiro, real e caracter que foram empregadas at o captulo 8 podem
ser denominadas de variveis simples. Mas tambm existem as chamadas variveis compostas ou
do tipo conjunto, que so o tema deste captulo 9.
b) Neste programa so usados trs novos comandos do FORTRAN: DIMENSION,
ALLOCATABLE e ALLOCATE, que so empregados com variveis do tipo conjunto. A sintaxe
deles, isto , a forma de utiliz-los mostrada na Tabela 9.2.
c) Em FORTRAN, conjunto uma coleo de variveis do mesmo tipo que so agrupadas numa
nica varivel. Cada varivel que compe o conjunto denominada de elemento ou componente.
Uma varivel do tipo conjunto tambm chamada de vetor ou varivel subscrita. As variveis do
tipo conjunto podem ser compostas por variveis do tipo inteiro, real ou caracter. Por exemplo, as
diversas notas de uma prova podem ser agrupadas num nico conjunto ou varivel (NOTAS) para
Captulo 9. Conjuntos 104

represent-las, conforme mostrado na Tabela 9.1.
d) O comando DIMENSION(:) usado para definir uma varivel do tipo conjunto.

INTEGER NOTA, QUANTIDADE_NOTAS
REAL, ALLOCATABLE, DIMENSION(:) :: NOTAS

REAL MINIMO, MAXIMO, SOMA, MEDIA
WRITE(*,*) "Entre com a quantidade de notas"

READ(*,*) QUANTIDADE_NOTAS
ALLOCATE ( NOTAS (QUANTIDADE_NOTAS) )
WRITE(*,*) "Entre com as notas"
DO NOTA = 1, QUANTIDADE_NOTAS
READ(*,*) NOTAS(NOTA)
END DO
MINIMO = NOTAS(1)
MAXIMO = NOTAS(1)
SOMA = NOTAS(1)
IF ( NOTAS(NOTA) < MINIMO ) MINIMO = NOTAS(NOTA)
IF ( NOTAS(NOTA) > MAXIMO ) MAXIMO = NOTAS(NOTA)
SOMA = SOMA + NOTAS(NOTA)
END DO
MEDIA = SOMA / QUANTIDADE_NOTAS
WRITE(*,*) "Nota minima = ", MINIMO

WRITE(*,*) "Nota maxima = ", MAXIMO
WRITE(*,*) "Nota media = ", MEDIA
END
e) O comando ALLOCATABLE usado para definir uma varivel do tipo alocvel, isto , uma
varivel do tipo conjunto cuja quantidade de elementos que a compe definida posteriormente
dentro do programa em funo de alguma outra varivel.
f) O comando ALLOCATE usado para definir quantos elementos compem uma varivel do tipo
conjunto e reservar o espao de memria correspondente no computador. No se pode atribuir
valores aos componentes de uma varivel do tipo conjunto antes do comando ALLOCATE ter
sido usado com ela.
g) Na linha REAL, ALLOCATABLE, DIMENSION(:) :: NOTAS do programa, define-se a varivel
chamada NOTAS com as seguintes caractersticas: do tipo conjunto, devido ao comando
DIMENSION(:); do tipo alocvel, devido ao comando ALLOCATABLE; e do tipo real, ou seja,
cada elemento da varivel NOTAS poder conter nmeros reais, devido ao comando REAL. O
duplo dois pontos que aparece nesta linha deve ser usado quando existe mais de uma definio
para uma varivel, onde cada definio deve ser separada por vrgula.
h) Na linha ALLOCATE ( NOTAS (QUANTIDADE_NOTAS) ) do programa, utilizando-se o comando
ALLOCATE e a varivel QUANTIDADE_NOTAS, que um dado do programa, define-se
quantos elementos compem a varivel NOTAS e reserva-se o espao de memria
correspondente.
Tabela 9.2 Sintaxe de comandos para variveis do tipo conjunto.
PARA DEFINIR O TIPO DE VARIAVL:

REAL, ALLOCATABLE, DIMENSION(:) :: A, B
INTEGER, ALLOCATABLE, DIMENSION(:) :: A, B
CHARACTER(X), ALLOCATABLE, DIMENSION(:) :: A, B
PARA ALOCAR A MEMRIA DOS CONJUNTOS:

ALLOCATE ( A(N1), B(N2) )
onde X um valor inteiro que define o nmero de caracteres, e

N1 e N2 so variveis do tipo inteiro que definem a quantidade de elementos de cada
conjunto.
i) Cada elemento de uma varivel do tipo conjunto referenciado por um nmero inteiro, chamado
ndice, que corresponde ordem dele dentro do conjunto. Este ndice deve ficar entre parnteses
aps o nome da varivel do tipo conjunto. O ndice ou o nmero do elemento pode ser
representado por uma varivel, por exemplo, na linha READ(*,*) NOTAS(NOTA) do programa, que
est dentro de um ciclo. Neste ciclo, a varivel NOTA corresponde a cada elemento da varivel
NOTAS.
j) Na linha MINIMO = NOTAS(1) do programa, est sendo inicializado o valor da varivel MINIMO
atribuindo a ela o valor do primeiro elemento da varivel NOTAS. O mesmo ocorre nas duas
linhas seguintes com as variveis MAXIMO e SOMA.

k) No ciclo definido pela linha DO NOTA = 2, QUANTIDADE_NOTAS do programa, com o emprego de
comandos IF, so determinados os valores MINIMO e MAXIMO dos elementos da varivel
NOTAS, assim como a SOMA dos valores de todos os elementos.
7) Algoritmo do programa:
a) Definir os tipos de todas as variveis
b) Ler a quantidade de elementos da varivel NOTAS, que do tipo conjunto ou vetor
c) Alocar a memria para a varivel NOTAS
d) Ler os valores de todos os elementos da varivel NOTAS
e) Determinar os valores mnimo e mximo e a mdia da varivel NOTAS
f) Escrever e identificar os valores mnimo e mximo e a mdia da varivel NOTAS
a) Na primeira linha, o comentrio Entre com a quantidade de notas, resultado do comando
WRITE(*,*) "Entre com a quantidade de notas" do programa.
b) Na segunda linha, o programa pra e fica aguardando que seja fornecido o valor da varivel
QUANTIDADE_NOTAS, resultado do comando READ(*,*) QUANTIDADE_NOTAS do programa.
Para que o programa continue sua execuo necessrio digitar 5, por exemplo, e, em seguida,
clicar na tecla Enter.
c) Na terceira linha, o comentrio Entre com as notas, resultado do comando WRITE(*,*) "Entre
com as notas" do programa.
d) Na quarta linha, o programa pra e fica aguardando que sejam fornecidos os valores de todos os
elementos da varivel NOTAS, resultado do comando READ(*,*) NOTAS(NOTA) do programa,
que est dentro de um ciclo que comea 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 necessrio 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 so apresentados os resultados correspondentes execuo do programa.
11) At entender, analisar os resultados do programa9a.f90, mostrados na Figura 9.1, considerando cada
linha do programa-fonte, as explicaes descritas no item 6 acima e a mdia 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 explicaes descritas no item 6 acima
e a mdia obtida com o uso de uma calculadora.

9.2 programa9b.f90
1) Nesta seo ser usado o programa9a.f90, da seo anterior, como base para um novo programa.
a) Selecionar todas as linhas do programa9a.f90 com o boto esquerdo do mouse
b) Edit, Copy para salvar este programa-fonte na memria do computador
Fortran:
a) Clicar sobre o nome do programa9a.f90
b) Edit, Cut para retirar o programa9a.f90 do projeto.
programa9b.f90
4) No Fortran, executar Edit, Paste para inserir o programa9a.f90 dentro do programa9b.f90.
5) Dentro do espao de edio do Fortran, na subjanela maior, alterar o programa9a.f90 para que fique
exatamente igual ao texto em vermelho mostrado na Tabela 9.3.
a) Utilizar trs novas funes matemticas intrnsecas do FORTRAN: MINVAL, MAXVAL e SUM,
que so utilizadas com variveis do tipo conjunto
b) Determinar os valores mnimo e mximo e a mdia de um conjunto de variveis do tipo real
a) Neste programa emprega-se exatamente o mesmo algoritmo do programa anterior, isto , os dois
programas fazem exatamente o mesmo. A diferena que neste programa os valores mnimo e
mximo e a mdia de um conjunto de variveis do tipo real so obtidos atravs de trs novas
funes matemticas intrnsecas do FORTRAN: MINVAL, MAXVAL e SUM, que so utilizadas
com variveis do tipo conjunto. A sintaxe delas, isto , a forma de utiliz-las exemplificada na
Tabela 9.3. Com isso, o que foi realizado com oito linhas de programa-fonte no programa9a.f90,
empregando um ciclo e comandos IF, reduziu-se a trs linhas no programa9b.f90.

INTEGER NOTA, QUANTIDADE_NOTAS
REAL, ALLOCATABLE, DIMENSION(:) :: NOTAS
REAL MINIMO, MAXIMO, SOMA, MEDIA
WRITE(*,*) "Entre com a quantidade de notas"

READ(*,*) QUANTIDADE_NOTAS
ALLOCATE ( NOTAS (QUANTIDADE_NOTAS) )
WRITE(*,*) "Entre com as notas"
READ(*,*) NOTAS(NOTA)
END DO
MINIMO = MINVAL(NOTAS)
MAXIMO = MAXVAL(NOTAS)
SOMA = SUM(NOTAS)
MEDIA = SOMA / QUANTIDADE_NOTAS
WRITE(*,*) "Nota minima = ", MINIMO

WRITE(*,*) "Nota maxima = ", MAXIMO
WRITE(*,*) "Nota media = ", MEDIA
END
b) O comando B = MINVAL(A) determina o valor mnimo entre todos os elementos da varivel do

tipo conjunto A e atribui o resultado varivel simples B.
c) O comando B = MAXVAL(A) determina o valor mximo entre todos os elementos da varivel do
tipo conjunto A e atribui o resultado varivel simples B.
d) O comando B = SUM(A) calcula a soma dos valores de todos os elementos da varivel do tipo
conjunto A e atribui o resultado varivel simples B.

10) Ao se executar o programa, atravs de Build, Execute, ocorre o mesmo j explicado no item 10 da
seo 9.1 deste captulo, e o resultado obtido o mesmo j mostrado na Figura 9.1.
9.3 programa9c.f90
Fortran:
a) Clicar sobre o nome do programa9b.f90
b) Edit, Cut para retirar o programa9b.f90 do projeto.
programa9c.f90
a) Mostrar como realizar operaes com todos os elementos de um conjunto num nico comando
b) Mostrar o uso de funes matemticas intrnsecas do FORTRAN com variveis do tipo conjunto
c) Mostrar duas formas de escrever o contedo de variveis do tipo conjunto
a) Na linha REAL, ALLOCATABLE, DIMENSION(:) :: CONJUNTO_A, CONJUNTO_B, CONJUNTO_C do
programa, esto sendo definidas trs variveis (CONJUNTO_A, CONJUNTO_B e
CONJUNTO_C) com as seguintes caractersticas: do tipo conjunto, devido ao comando
DIMENSION(:); do tipo alocvel, devido ao comando ALLOCATABLE; e do tipo real, ou seja,
cada elemento das trs variveis poder conter nmeros 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 varivel CONJUNTO_A e atribui-se o resultado a cada elemento da varivel
CONJUNTO_B. Portanto, num nico comando esto sendo feitos clculos com todos os
elementos de um conjunto. Para que isso seja possvel, as duas variveis do tipo conjunto tm que
ter exatamente o mesmo nmero de elementos. Esta linha do programa poderia ser substituda 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 varivel CONJUNTO_A e atribui-se o resultado a cada elemento da varivel
CONJUNTO_C. Assim, num nico comando esto sendo feitos clculos com todos os elementos
de um conjunto envolvendo uma funo matemtica intrnseca do FORTRAN, no caso a funo
exponencial (EXP). Mas tambm podem ser usadas outras funes como aquelas apresentadas nas
Tabelas 5.5 e 5.6. Esta linha do programa tambm poderia ser substituda de forma equivalente ao
seguinte:
CONJUNTO_C(ELEMENTO) = EXP(CONJUNTO_A(ELEMENTO))
END DO

INTEGER ELEMENTO, QUANTIDADE_ELEMENTOS
REAL, ALLOCATABLE, DIMENSION(:) :: CONJUNTO_A, CONJUNTO_B, CONJUNTO_C
WRITE(*,*) "Entre com a quantidade de elementos do CONJUNTO_A"

READ(*,*) QUANTIDADE_ELEMENTOS
ALLOCATE ( CONJUNTO_A(QUANTIDADE_ELEMENTOS), &

CONJUNTO_B(QUANTIDADE_ELEMENTOS), &
CONJUNTO_C(QUANTIDADE_ELEMENTOS) )
WRITE(*,*) "Entre com os valores do CONJUNTO_A"
READ(*,*) CONJUNTO_A(ELEMENTO)
END DO
CONJUNTO_B = CONJUNTO_A + 10
CONJUNTO_C = EXP(CONJUNTO_A)
WRITE(*,*) "CONJUNTO_B = ", CONJUNTO_B
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 varivel do tipo conjunto. A
primeira agir da mesma forma que no caso de uma varivel simples. Por exemplo, como
resultado da linha WRITE(*,*) "CONJUNTO_B = ", CONJUNTO_B do programa, sero escritos os
valores de todos os elementos da varivel CONJUNTO_B, na seqncia do primeiro ao ltimo

elemento, no formato default do FORTRAN. A segunda forma escrever o valor de cada
elemento atravs de um ciclo, com ou sem formato de edio. Um exemplo disso apresentado no
ltimo ciclo do programa9c.f90.
b) Ler a quantidade de elementos das variveis do tipo conjunto
c) Alocar a memria para as trs variveis do tipo conjunto chamadas CONJUNTO_A,
CONJUNTO_B e CONJUNTO_C
d) Ler os valores de todos os elementos da varivel CONJUNTO_A
e) Somar o valor 10 ao valor de cada elemento da varivel CONJUNTO_A e atribuir o resultado a
cada elemento da varivel CONJUNTO_B
f) calcular a exponencial do valor de cada elemento da varivel CONJUNTO_A e atribuir o
resultado a cada elemento da varivel CONJUNTO_C
g) Escrever os valores de todos os elementos das variveis CONJUNTO_B e CONJUNTO_C
a) Na primeira linha, o comentrio Entre com a quantidade de elementos do CONJUNTO_A,
resultado do comando WRITE(*,*) "Entre com a quantidade de elementos do
CONJUNTO_A" do programa.
QUANTIDADE_ELEMENTOS, resultado do comando READ(*,*) QUANTIDADE_ELEMENTOS do
programa. Para que o programa continue sua execuo necessrio digitar 6, por exemplo, e, em
seguida, clicar na tecla Enter.
c) Na terceira linha, o comentrio 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 pra e fica aguardando que sejam fornecidos os valores de todos os
elementos da varivel CONJUNTO_A, resultado do comando READ(*,*)
CONJUNTO_A(ELEMENTO) do programa, que est dentro de um ciclo que comea 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 necessrio 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 so apresentados os resultados correspondentes execuo do programa.

Figura 9.2 Resultado do programa9c.f90.
10) At entender, analisar os resultados do programa9c.f90, mostrados na Figura 9.2, considerando cada
linha do programa-fonte e as explicaes 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 explicaes descritas no item 5 acima.
9.4 programa9d.f90
Fortran:
a) Clicar sobre o nome do programa9c.f90
b) Edit, Cut para retirar o programa9c.f90 do projeto.
programa9d.f90
4) Objetivo do programa: aplicar os conceitos j vistos nas sees anteriores deste captulo ao caso de
uma progresso aritmtica (P.A.) onde os valores dos elementos da varivel do tipo conjunto so
inteiros.
b) Ler o nmero de termos da progresso aritmtica (P.A.)
c) Alocar a memria para a varivel do tipo conjunto chamada A
d) Ler os valores do primeiro termo da P.A. e a diferena entre dois termos subseqentes
e) Calcular os valores dos termos da P.A. e atribu-los varivel A
f) Calcular a soma dos valores de todos os elementos da P.A.
g) Escrever os valores de todos os elementos da P.A. e a soma deles

INTEGER TERMO, N, SN, D
INTEGER, ALLOCATABLE, DIMENSION(:) :: A
WRITE(*,*) "Todas as variaveis sao do tipo inteiro"
WRITE(*,*) "Entre com o numero de termos da P.A."

READ(*,*) N
ALLOCATE ( A(N) )
WRITE(*,*) "Entre com o primeiro termo da P.A."

READ(*,*) A(1)
WRITE(*,*) "Entre com a diferenca entre dois termos subsequentes"

READ(*,*) D
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
WRITE(*,*) "Soma dos termos = ", SN
END


dentro da qual so solicitados os dados (usar, por exemplo, 10, 1 e 2) e, em seguida, apresentados
os resultados da execuo do programa.
9) At entender, analisar os resultados do programa9d.f90, mostrados na Figura 9.3, considerando cada
linha do programa-fonte.
10) Executar novamente o programa com outros dados. At entender, analisar os novos resultados
considerando cada linha do programa-fonte.
Figura 9.3 Resultado do programa9d.f90.
9.5 EXERCCIOS
Exerccio 9.1
Adaptar o programa9d.f90 para escrever os valores dos termos da progresso aritmtica num arquivo,
bem como a soma dos valores de todos os termos
Exerccio 9.2
Adaptar o programa9d.f90 para calcular e escrever os valores dos termos de uma progresso geomtrica
num arquivo, bem como a soma dos valores de todos os termos
Exerccio 9.3
1) Definir os tipos de todas as variveis, sendo uma delas do tipo conjunto para caracteres, chamada
NOMES
2) Ler a quantidade de elementos da varivel NOMES
3) Alocar a memria para a varivel NOMES
4) Ler os contedos de todos os elementos da varivel NOMES
5) Escrever num arquivo o contedo de cada elemento da varivel NOMES
Exerccio 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-padro (D) das notas, definido por
(N
i =1
m Ni )2
D =
N
onde N o nmero de notas, Nm a mdia das notas, e Ni cada nota.
Exerccio 9.5
1) Ler os valores inteiros de cinco variveis
2) Ordenar e escrever as cinco variveis em ordem crescente de valor
3) Ordenar e escrever as cinco variveis em ordem decrescente de valor
Exerccio 9.6
1) Ler os valores inteiros de cinco variveis
2) Determinar e escrever quais variveis tm valor par
3) Determinar e escrever quais variveis tm valor mpar
4) Calcular a soma dos valores pares
5) Calcular a soma dos valores mpares

Captulo 10. MATRIZES
Conceitos de: conjunto multidimensional (matriz), ciclo implcito, ciclo duplo
Comandos do FORTRAN: DIMENSION(:,:), MATMUL
10.1 programa10a.f90

programa10a.f90
a) Aplicar os comandos DIMENSION, ALLOCATABLE e ALLOCATE a um conjunto
bidimensional (matriz) do tipo inteiro
b) Ler os elementos da matriz e escrev-los utilizando ciclos duplos
a) Neste programa os comandos DIMENSION, ALLOCATABLE e ALLOCATE so aplicados a
uma varivel do tipo conjunto bidimensional, que tambm chamada de matriz. A sintaxe deles,
isto , a forma de utiliz-los mostrada na Tabela 10.2.
b) Em FORTRAN, conjunto bidimensional um conjunto no qual so necessrios dois ndices para
localizar cada elemento em sua estrutura. Portanto, os conjuntos empregados no captulo 9 podem
ser classificados como conjuntos unidimensionais pois basta um nico ndice para localizar cada
elemento dentro deles.
c) Generalizando, existem os conjuntos multidimensionais, isto , aqueles nos quais so necessrios
diversos ndices (2, 3, etc) para localizar cada elemento dentro deles. Em FORTRAN, os
conjuntos podem ter at sete dimenses ou ndices. Um exemplo de conjunto tridimensional
aquele onde se armazenam as coordenadas X, Y e Z de um slido tridimensional.
Captulo 10. Matrizes 117

d) Todos os conceitos vistos no captulo 9 para conjuntos unidimensionais tambm so vlidos para
conjuntos multidimensionais.
e) O comando DIMENSION(:,:) usado para definir uma varivel do tipo conjunto bidimensional.

INTEGER LINHA, LINHAS, COLUNA, COLUNAS
INTEGER, ALLOCATABLE, DIMENSION(:,:) :: MATRIZ
WRITE(*,*) "Entre com o numero de linhas da matriz"

READ(*,*) LINHAS
WRITE(*,*) "Entre com o numero de colunas da matriz"
READ(*,*) COLUNAS
ALLOCATE ( MATRIZ ( LINHAS, COLUNAS ) )
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
WRITE(*,*) "Escrita da MATRIZ sem formato"

WRITE(*,*) MATRIZ
WRITE(*,*) "Escrita da MATRIZ na mesma sequencia dos dados"

WRITE(*,1) LINHA, COLUNA, MATRIZ(LINHA,COLUNA)
1 FORMAT( 3X, "MATRIZ(", I1, ",", I1, ") = ", I5)
END DO
END DO
END
f) Uma das principais aplicaes de conjuntos uni e bidimensionais a resoluo de sistemas de

equaes algbricas representados por
[A][X ] = [B] (10.1)

onde [A] a matriz (conjunto bidimensional) dos coeficientes do sistema de equaes; [X] o
vetor (conjunto unidimensional) incgnita, isto , representa as variveis a determinar com a
resoluo do sistema; e [B] o vetor (conjunto unidimensional) independente, ou seja, ele contm
valores conhecidos.
g) Na linha INTEGER, ALLOCATABLE, DIMENSION(:,:) :: MATRIZ do programa, define-se a
varivel chamada MATRIZ com as seguintes caractersticas: do tipo conjunto bidimensional
(matriz), devido ao comando DIMENSION(:,:); do tipo alocvel, devido ao comando
ALLOCATABLE; e do tipo inteiro, ou seja, cada elemento da varivel MATRIZ poder conter
nmeros inteiros, devido ao comando INTEGER.
h) Na linha ALLOCATE ( MATRIZ ( LINHAS, COLUNAS ) ) do programa, utilizando-se o comando
ALLOCATE e as variveis LINHAS e COLUNAS, que so dados do programa, define-se,
respectivamente, quantos elementos existem em cada linha e em cada coluna da varivel MATRIZ
e reserva-se o espao de memria correspondente.
Tabela 10.2 Sintaxe de comandos para variveis do tipo matriz (conjunto bidimensional).
PARA DEFINIR O TIPO DE VARIAVL:

REAL, ALLOCATABLE, DIMENSION(:,:) :: A, B
INTEGER, ALLOCATABLE, DIMENSION(:,:) :: A, B
CHARACTER(X), ALLOCATABLE, DIMENSION(:,:) :: A, B
PARA ALOCAR A MEMRIA DOS CONJUNTOS:

ALLOCATE ( A(L,C), B(L,C) )
onde X um valor inteiro que define o nmero de caracteres,

L e C so variveis do tipo inteiro que definem, respectivamente, a quantidade de
elementos numa linha e numa coluna das matrizes A e B.
i) Cada elemento de uma varivel do tipo conjunto bidimensional referenciado por dois nmeros
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 parnteses, e separados por vrgula, aps o nome da varivel do tipo
conjunto bidimensional. Os ndices ou os nmeros do elemento podem ser representados por
variveis, por exemplo, na linha READ(*,*) MATRIZ(LINHA,COLUNA) do programa, que est
dentro de um ciclo duplo.

j) Ciclo duplo quando tem-se um ciclo dentro de outro. So usados dois ciclos duplos no
programa10a.f90. Um deles
WRITE(*,1) LINHA, COLUNA, MATRIZ(LINHA,COLUNA)
1 FORMAT( 3X, "MATRIZ(", I1, ",", I1, ") = ", I5)
END DO
END DO
Recomenda-se identar, isto , deslocar para a direita todas as linhas do programa que esto entre
os comandos DO e END DO. Assim, facilmente se percebe os comandos que compem o ciclo.
No caso de ciclos duplos, deve-se usar uma identao para cada ciclo, conforme o exemplo
mostrado neste item, acima.
k) So usadas duas formas para escrever os valores dos elementos de uma varivel do tipo conjunto
bidimensional. A primeira agir da mesma forma que no caso de uma varivel simples, por
exemplo, a linha WRITE(*,*) MATRIZ do programa. Nesta forma a matriz escrita no formato
default do FORTRAN que : primeiro, escrever os valores de todos os elementos da primeira
coluna, indo da primeira ltima linha; repetir o procedimento para a segunda coluna, e assim por
diante at a ltima coluna. A segunda forma escrever o valor de cada elemento atravs de um
ciclo duplo, com ou sem formato de edio. Um exemplo disso apresentado no final do
programa10a.f90
b) Ler a quantidade de elementos em cada linha e coluna da varivel MATRIZ, que do tipo
conjunto bidimensional
c) Alocar a memria para a varivel MATRIZ
d) Ler os valores de todos os elementos da varivel MATRIZ
e) Escrever o contedo da varivel MATRIZ sem utilizar formato de edio
f) Escrever os dois ndices e o valor correspondente a cada elemento da varivel MATRIZ utilizando
formatos de edio
a) Na primeira linha, o comentrio Entre com o numero de linhas da matriz, resultado do comando
WRITE(*,*) "Entre com o numero de linhas da matriz" do programa.

LINHAS, resultado do comando READ(*,*) LINHAS do programa. Para que o programa continue
sua execuo necessrio digitar 3, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentrio Entre com o numero de colunas da matriz, resultado do comando
WRITE(*,*) "Entre com o numero de colunas da matriz" do programa.
d) Na quarta linha, o programa pra e fica aguardando que seja fornecido o valor da varivel
COLUNAS, resultado do comando READ(*,*) COLUNAS do programa. Para que o programa
continue sua execuo necessrio digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, o comentrio 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 pra e fica aguardando que sejam fornecidos os valores de todos os
elementos da primeira linha da matriz, resultado dos comandos
READ(*,*) MATRIZ(LINHA,COLUNA)
END DO
do programa, que contm um ciclo que comea 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 necessrio digitar cada valor e, em seguida, clicar na tecla Enter antes de se digitar

um novo valor. Usar, por exemplo, os valores 1, 4, 2, 5, 3 e 6. Estes dados, nesta seqncia,
correspondem seguinte matriz:
1 4
(10.2)
2 5
3 6
g) Em seguida so apresentados os resultados correspondentes execuo do programa.

11) At entender, analisar os resultados do programa10a.f90, mostrados na Figura 10.1, considerando
cada linha do programa-fonte e as explicaes descritas no item 6 acima.
12) Executar novamente o programa com outros dados. At entender, analisar os novos resultados do
programa10a.f90 considerando cada linha do programa-fonte e as explicaes descritas no item 6
acima.
10.2 programa10b.f90
1) Nesta seo ser usado o programa10a.f90, da seo anterior, como base para um novo programa.
a) Selecionar todas as linhas do programa10a.f90 com o boto esquerdo do mouse
b) Edit, Copy para salvar este programa-fonte na memria do computador
Fortran:
a) Clicar sobre o nome do programa10a.f90
b) Edit, Cut para retirar o programa10a.f90 do projeto.
programa10b.f90
4) No Fortran, executar Edit, Paste para inserir o programa10a.f90 dentro do programa10b.f90.
5) Dentro do espao de edio do Fortran, na subjanela maior, alterar o programa10a.f90 para que
fique exatamente igual ao texto em vermelho mostrado na Tabela 10.3.
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
implcitos
c) Realizar operaes matemticas com matrizes

a) Com os ciclos usados no programa da seo anterior, programa10a.f90, consegue-se ler apenas um
elemento da matriz por vez, isto , a cada comando Enter. J neste programa10b.f90, com o bloco
de linhas do programa
WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A da linha =", LINHA
READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
consegue-se ler os valores de todos os elementos de cada linha da MATRIZ_A. Isso possvel
porque: existe um ciclo externo, definido pela linha DO LINHA = 1, LINHAS do programa, que a
cada execuo percorre uma linha da matriz; e tambm existe um ciclo chamado de implcito na
linha READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS ) do programa, que a
cada execuo percorre todas as colunas da matriz.
b) O chamado ciclo implcito 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.

USE PORTLIB
INTEGER LINHA, LINHAS, COLUNA, COLUNAS, CONSTANTE, VER

REAL,ALLOCATABLE,DIMENSION(:,:) :: MATRIZ_A, MATRIZ_B, MATRIZ_C
WRITE(*,*) "Entre com o valor da CONSTANTE (inteiro)"

READ(*,*) CONSTANTE
WRITE(*,*) "Entre com o numero de linhas das matrizes (inteiro)"
READ(*,*) LINHAS
WRITE(*,*) "Entre com o numero de colunas das matrizes (inteiro)"
READ(*,*) COLUNAS
ALLOCATE ( MATRIZ_A(LINHAS,COLUNAS), MATRIZ_B(LINHAS,COLUNAS), &

MATRIZ_C(LINHAS,COLUNAS) )
WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A da linha =", LINHA
READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
MATRIZ_B(LINHA,COLUNA) = CONSTANTE * MATRIZ_A(LINHA,COLUNA)

END DO
END DO
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) ***")
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) ***")
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) ***")
WRITE(10,33) ( MATRIZ_C(LINHA,COLUNA), COLUNA = 1, COLUNAS )
END DO
CLOSE(10)
VER = SYSTEM("Notepad SAIDA10B.TXT")
END
c) Com o bloco de linhas do programa


MATRIZ_B(LINHA,COLUNA) = CONSTANTE * MATRIZ_A(LINHA,COLUNA)
END DO
END DO
o valor de cada elemento da MATRIZ_A multiplicado pela varivel CONSTANTE e o resultado
atribudo a cada elemento da MATRIZ_B.
d) Com o bloco de linhas do programa
MATRIZ_C(LINHA,COLUNA) = MATRIZ_A(LINHA,COLUNA) + MATRIZ_B(LINHA,COLUNA)
END DO
END DO
o valor de cada elemento da MATRIZ_A adicionado ao valor de cada elemento da MATRIZ_B
e o resultado atribudo a cada elemento da MATRIZ_C.
e) Com o bloco de linhas do programa
WRITE(10,33) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
33 FORMAT( 10 (3X, 1PE10.3 ) )
END DO
escreve-se o contedo da varivel MATRIZ_A em formato de matriz atravs de um ciclo simples
(externo) e um ciclo implcito (interno). O formato de edio empregado 10 (3X, 1PE10.3 )
permite que sejam escritos at 10 elementos a cada linha com trs colunas entre cada um (3X),
utilizando o formato 1PE10.3 para nmeros reais.
f) Com conjuntos multidimensionais, tambm se pode fazer simultaneamente operaes com todos
os elementos, conforme j visto no programa9c.f90 do captulo 9 para conjuntos unidimensionais.
Por exemplo, as cinco linhas de programa mostradas no item c acima podem ser substitudas de
forma equivalente a apenas
MATRIZ_B = CONSTANTE * MATRIZ_A
E as cinco linhas de programa mostradas no item d acima podem ser substitudas de forma
equivalente a apenas
MATRIZ_C = MATRIZ_A + MATRIZ_B
g) Com conjuntos multidimensionais, tambm se pode utilizar as funes intrnsecas das Tabelas 5.5
e 5.6, conforme j visto no programa9c.f90 do captulo 9 para conjuntos unidimensionais.
b) Ler o valor do tipo inteiro de uma constante e a quantidade de elementos em cada linha e coluna
das variveis MATRIZ_A, MATRIZ_B e MATRIZ_C, que so do tipo conjunto bidimensional
c) Alocar memria para as trs variveis do tipo matriz
d) Ler os valores de todos os elementos da varivel MATRIZ_A no formato de matriz

e) calcular o valor de cada elemento da MATRIZ_B atravs da multiplicao do valor de cada
elemento da MATRIZ_A pela varivel CONSTANTE
f) calcular o valor de cada elemento da MATRIZ_C atravs da adio do valor de cada elemento da
MATRIZ_A pelo valor de cada elemento da MATRIZ_B
g) Escrever num arquivo o valor da CONSTANTE e o contedo das variveis MATRIZ_A,
MATRIZ_B e MATRIZ_C em formato de matriz com os dois ndices de cada elemento
a) Na primeira linha, o comentrio Entre com o valor da CONSTANTE (inteiro), resultado do
comando WRITE(*,*) "Entre com o valor da CONSTANTE (inteiro)" do programa.
CONSTANTE, resultado do comando READ(*,*) CONSTANTE do programa. Para que o programa
Figura 10.2 Janela DOS do programa10b.f90.
c) Na terceira linha, o comentrio 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 pra e fica aguardando que seja fornecido o valor da varivel
LINHAS, resultado do comando READ(*,*) LINHAS do programa. Para que o programa continue
e) Na quinta linha, o comentrio Entre com o numero de colunas das matrizes (inteiro), resultado do
comando WRITE(*,*) "Entre com o numero de colunas das matrizes (inteiro)" do
programa.

f) Na sexta linha, o programa pra e fica aguardando que seja fornecido o valor da varivel
COLUNAS, resultado do comando READ(*,*) COLUNAS do programa. Para que o programa
g) Na stima linha, o comentrio Entre com os valores dos elementos da MATRIZ_A da linha = 1,
resultado do comando WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A
da linha =", LINHA do programa.
h) Na oitava linha, o programa pra 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 seqncia, correspondem seguinte matriz:
1 4

2 5 (10.3)
3 6
i) Em seguida, o aplicativo Notepad apresenta os resultados correspondentes execuo do

programa no arquivo SAIDA10B.TXT, mostrado na Figura 10.3.
Figura 10.3 Arquivo SAIDA10B.TXT do programa10b.f90.
12) At entender, analisar os resultados do programa10b.f90, mostrados na Figura 10.3, considerando

cada linha do programa-fonte e as explicaes descritas no item 7 acima.

13) Executar novamente o programa com outros dados. At entender, analisar os novos resultados do
programa10b.f90 considerando cada linha do programa-fonte e as explicaes descritas no item 7
acima.
10.3 EXERCCIOS
Exerccio 10.1
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
Exerccio 10.2
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
Exerccio 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) nmero de linhas da Matriz_A
b) nmero de colunas da Matriz_A
c) nmero 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 variveis e elementos
4) Calcular a Matriz_D atravs da seguinte linha inserida dentro do programa-fonte:
Matriz_D = MATMUL ( Matriz_A, Matriz_B )
onde o comando MATMUL uma funo intrnseca do FORTRAN que calcula o produto de duas
matrizes
5) Escrever num arquivo a Matriz_D identificando seus elementos; ela deve ser idntica Matriz_C

Captulo 11. GRFICOS COM WGNUPLOT
Aprender a utilizar o aplicativo Wgnuplot para fazer grficos
Aprender a utilizar o aplicativo Wgnuplot interativamente com um programa em FORTRAN
11.1 INSERO DO APLICATIVO WGNUPLOT NUM PROJETO

3) Acessar o site da disciplina em ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/
4) Clicar com o boto do lado direito do mouse sobre o arquivo WGNUPLOT.EXE
5) Escolher a opo Save Target As
6) Na opo Save in, localizar o diretrio do projeto
7) Clicar no boto Save
8) Repetir os itens 3 a 7 acima para os arquivos WGNUPLOT.HLP e WGNUPLOT.MNU
11.2 UTILIZAO BSICA DO WGNUPLOT
1) O Wgnuplot um software livre utilizado para fazer grficos bi e tridimensionais. Um manual bsico
sobre ele est disponvel em ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/Wgnuplot.pdf
2) Para iniciar sua utilizao, basta clicar duas vezes sobre o arquivo Wgnuplot.exe ou Application.
O resultado deve ser o mostrado na Figura 11.1.
3) Informaes detalhadas sobre a utilizao do Wgnuplot podem ser vistas no menu principal do
programa, na opo Help, Index
4) Informaes detalhadas sobre os comandos do Wgnuplot podem ser vistas no menu principal do
programa, na opo Help, Index, commands. Escolher, por exemplo, o comando plot.
5) Para gerar um grfico, 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 aps ser acionado o programa.
Captulo 11. Grficos com Wgnuplot 130
6) O comando plot usado para mostrar o grfico de funes definidas atravs de um arquivo de dados
ou de funes pr-definidas no Wgnuplot ou, ainda, de funes criadas pelo usurio. Por exemplo,
para visualizar o grfico da funo seno, deve-se digitar plot sin(x) na linha de comando do
Wgnuplot, conforme mostrado na Figura 11.2, e, em seguida, clicar na tecla Enter. Surgir uma
nova janela com o grfico da funo seno, mostrado na Figura 11.3. Nas abscissas apresentado x em
radianos, e nas ordenadas, o valor da funo seno.
Figura 11.1 Janela inicial do aplicativo Wgnuplot, verso 3.5.
Figura 11.2 Insero do comando plot sin(x) na linha de comando do aplicativo Wgnuplot.

7) O comando set xrange[x1:x2] usado para definir o intervalo dos valores das abscissas, isto , x,
mostrado no grfico, onde x1 e x2 so os valores mnimo e mximo, respectivamente. Por exemplo,
para definir o intervalo dos valores de x entre os nmeros 0 e 5, na linha de comando do Wgnuplot,
deve-se digitar set xrange[0:5]. Em seguida, clicar na tecla Enter. Sempre que um novo comando
inserido para alterar o grfico, como o set xrange, para visualizar o novo grfico necessrio digitar
replot na linha de comando e clicar na tecla Enter. Em seguida, surge o novo grfico. Portanto, para
visualizar o resultado do comando set xrange[0:5], deve-se digitar replot e, em seguida, clicar na
tecla Enter.
Figura 11.3 Grfico da funo seno conforme o comando do item 6 da seo 11.2.
8) O comando set yrange[y1:y2] usado para definir o intervalo dos valores das ordenadas, isto , y,
mostrado no grfico, onde y1 e y2 so os valores mnimo e mximo, respectivamente. Por exemplo,
para definir o intervalo dos valores de y entre os nmeros 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.

9) O comando set grid usado para facilitar a leitura dos valores de uma funo atravs de uma malha
ou grade no grfico. Na linha de comando do Wgnuplot, digitar set grid e clicar na tecla Enter.
Para visualizar o resultado, digitar replot e, em seguida, clicar na tecla Enter.
10) O comando set xlabel nomex usado para inserir uma legenda no eixo das abscissas, onde nomex
o nome da legenda a ser inserida, que deve ficar entre aspas. Aps clicar na tecla de aspas, deve-se
clicar na tecla de espao em branco para que as aspas apaream. Por exemplo, na linha de comando
do Wgnuplot, digitar set xlabel x e clicar na tecla Enter. Para visualizar o resultado, digitar
replot e, em seguida, clicar na tecla Enter.
11) O comando set ylabel nomey usado para inserir uma legenda no eixo das ordenadas, onde nomey
o nome da legenda a ser inserida, que deve ficar entre aspas. Por exemplo, na linha de comando do
Wgnuplot, digitar set ylabel seno e clicar na tecla Enter. Para visualizar o resultado, digitar
replot e, em seguida, clicar na tecla Enter.
12) O comando set title nome usado para inserir um ttulo para o grfico, onde nome o nome do
ttulo a ser inserido, que deve ficar entre aspas. Por exemplo, na linha de comando do Wgnuplot,
digitar set title Teste do aplicativo Wgnuplot e clicar na tecla Enter. Para visualizar o resultado,
digitar replot e, em seguida, clicar na tecla Enter.
13) O comando replot tambm usado para adicionar funes ou curvas a um grfico j existente. Por
exemplo, na linha de comando do Wgnuplot, digitar replot cos(x) e clicar na tecla Enter. A relao
de comandos dos itens 6 a 13 desta seo inseridos no Wgnuplot pode ser vista na Figura 11.4. O
grfico correspondente mostrado na Figura 11.5.
14) Entrar com o comando set xrange[0:1] e testar as seguintes funes:
a) plot x
b) plot x**2
15) O comando splot usado para fazer grficos tridimensionais. Testar os seguintes exemplos:
a) splot x+y
b) splot x*y
c) splot x**2
16) Para encerrar o Wgnuplot, deve-se executar File, Exit
11.3 UTILIZAO DO WGNUPLOT PARA FAZER GRFICO DE UM ARQUIVO DE DADOS
1) O aplicativo Wgnuplot pode ser usado para fazer grfico 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

Figura 11.4 Comandos usados nos itens 6 a 13 da seo 11.2.
b) Dentro do espao de edio do Notepad, digitar os seguintes nmeros em duas colunas separadas
por pelo menos um espao 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 diretrio do projeto. Em
seguida, clicar sobre o boto 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

4) Na linha de comando do Wgnuplot, digitar os seguintes comandos j vistos na seo anterior,
clicando na tecla Enter aps cada um deles:
set xlabel x
set ylabel y
set title Teste do Wgnuplot
set grid
Figura 11.5 Grfico resultante dos comandos usados nos itens 6 a 13 da seo 11.2.
5) O comando set data style linespoints utilizado para colocar um smbolo (crculo, 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 grfico 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 grfico
correspondente aos comandos usados nesta seo, que mostrado na Figura 11.6.
7) Encerrar o Wgnuplot com File, Exit

Figura 11.6 Grfico resultante dos comandos usados nos itens 1 a 6 da seo 11.3.
11.4 UTILIZAO DO WGNUPLOT COM ARQUIVO DE COMANDOS
1) O aplicativo Wgnuplot tambm pode ser usado para fazer grfico de um arquivo de dados utilizando
um arquivo com os comandos do prprio Wgnuplot. Isso facilita muito a gerao de grficos de forma
automatizada. A seguir, este novo procedimento aplicado ao mesmo exemplo da seo anterior
utilizando o arquivo comandos.txt. Para cri-lo com o aplicativo Notepad, executar o seguinte:
a) Start, Programs, Accessories, Notepad
b) Dentro do espao de edio 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
e) Ainda na janela Save As, dentro do campo Save in:, selecionar o diretrio do projeto. Em
seguida, clicar sobre o boto Save.
f) No aplicativo Notepad, executar File, Exit
2) Inicializar o aplicativo Wgnuplot clicando duas vezes sobre o arquivo Wgnuplot.exe ou
Application
3) Para gerar o grfico utilizando um arquivo de comandos, deve-se usar o comando load nome, onde
nome representa o nome do arquivo com comandos do Wgnuplot, que deve ficar entre aspas.
Portanto, na linha de comando do aplicativo Wgnuplot, digitar load comandos.txt e clicar na
tecla Enter. Em seguida, dever surgir o mesmo grfico da seo anterior, j mostrado na Figura
11.6. Deve-se notar que este novo grfico foi gerado sem qualquer comando ser digitado na linha de
comando do Wgnuplot, exceto o comando load.
4) Encerrar o Wgnuplot com File, Exit
5) Com o que foi visto nesta seo, pode-se, agora, gerar arquivos (dados.txt) com curvas de resultados
(os pares coordenados x-y) obtidos de programas em FORTRAN. E, dentro dos programas em
FORTRAN, chamar o aplicativo Wgnuplot para gerar os grficos correspondentes utilizando
arquivos de comandos (comandos.txt) do Wgnuplot. Na prxima seo mostrado como fazer isso.
11.5 programa11.f90
1) Nesta seo ser usado o mesmo projeto criado na seo 11.1. Portanto, no Fortran, seguindo o
procedimento-padro, criar e inserir no projeto o programa-fonte programa11.f90
a) Gerar um arquivo com as coordenadas x e y de uma curva
b) Plotar esta curva com o aplicativo Wgnuplot
a) O uso dos comandos USE e SYSTEM j foi explicado na seo 5.3 do captulo 5.
b) O comando SYSTEM vinha sendo usado para que o aplicativo Notepad abrisse arquivos com
resultados dos programas. No programa11.f90 ele tambm usado para acionar o aplicativo
Wgnuplot e gerar um grfico, com o procedimento visto na seo 11.4.
c) O arquivo de comandos do Wgnuplot utilizado no programa aquele criado na seo anterior,
chamado comandos.txt.
a) Unir a biblioteca PORTLIB ao programa para usar o comando SYSTEM
b) Definir os tipos de todas as variveis
c) Ler o nmero de pontos a usar para gerar o grfico
d) Calcular as coordenadas x e y, onde y = x3, e grav-las num arquivo chamado DADOS.TXT
e) Com o aplicativo Notepad, mostrar o contedo do arquivo DADOS.TXT
f) Com o aplicativo Wgnuplot, gerar um grfico com os dados do arquivo DADOS.TXT utilizando
os comandos do arquivo COMANDOS.TXT.
Tabela 11.1 Programa11.f90.

USE PORTLIB
REAL X, Y
INTEGER PONTO, PONTOS, VER
WRITE(*,*) "Entre com o numero de pontos"

READ(*,*) PONTOS
OPEN(7, FILE= "DADOS.TXT")
DO PONTO = 1, PONTOS
X = PONTO - 1
Y = X**3
WRITE(7,40) X, Y
40 FORMAT( 2 ( 1PE10.2 ) )
END DO
CLOSE(7)
VER = SYSTEM ("Notepad DADOS.TXT")
VER = SYSTEM ("Wgnuplot COMANDOS.TXT")
END

a) Na primeira linha, o comentrio Entre com o numero de pontos, resultado do comando
WRITE(*,*) "Entre com o numero de pontos" do programa.

PONTOS, resultado do comando READ(*,*) PONTOS do programa. Para que o programa continue
Figura 11.7 Janela DOS do programa11.f90.
c) Em seguida, o aplicativo Notepad apresenta as coordenadas x e y, onde y = x3, gravadas no

arquivo chamado DADOS.TXT, cujo contedo mostrado na Figura 11.8.
Figura 11.8 Arquivo DADOS.TXT do programa11.f90.
d) Fechar o aplicativo Notepad, com File, Exit. Deve surgir o grfico 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 explicaes descritas nas sees anteriores deste
captulo.
10) Executar novamente o programa com outro nmero de pontos.

11.6 EXERCCIOS
Exerccio 11.1
Adaptar o programa11.f90 para que ele gere o grfico y versus x onde y = logaritmo decimal de x
Exerccio 11.2
Adaptar o programa11.f90 para que ele gere o grfico y versus x onde y = cosseno hiperblico de x
Figura 11.9 Grfico gerado com o programa11.f90.

Captulo 12. SUB-ROTINAS
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

2) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa12a
principal1.f90
5) No Fortran, seguindo o procedimento-padro, criar e inserir no projeto o programa-fonte rotina1.f90
a) Aplicar os novos comandos PROGRAM, EXTERNAL, SUBROUTINE e CALL do FORTRAN
b) Utilizar uma sub-rotina externa ao programa-principal
a) Neste programa so usados quatro novos comandos do FORTRAN: PROGRAM, EXTERNAL,
SUBROUTINE e CALL. Eles so aplicados com o que se denomina em programao de sub-
rotina.
b) Sub-rotinas so programas inseridos ou usados por um programa-principal.
c) O programa-principal o programa-fonte que contm o algoritmo que se deseja executar e que usa
as sub-rotinas.
d) As sub-rotinas podem estar contidas dentro do programa-principal ou podem estar dentro de
outros programas-fonte. O primeiro caso ser exemplificado na seo 12.4 deste captulo. J o
Captulo 12. Sub-rotinas 141

segundo caso exemplificado na presente seo e nas duas seguintes. Neste caso, isto , quando
h mais de um programa-fonte que constitui um projeto, usa-se o comando PROGRAM para

definir qual programa-fonte o programa-principal. E o comando EXTERNAL usado para
informar ao programa-principal quais so os outros programas-fonte que fazem parte do projeto.
Outra forma de usar sub-rotinas utilizar o comando USE para incluir uma biblioteca dentro do
programa-principal, para que este possa chamar as sub-rotinas desejadas da biblioteca.
Tabela 12.1 Programa-fonte principal1.f90.

PROGRAM CAPITULO_12A
EXTERNAL ROTINA1
REAL A, B, C

READ(*,*) A

READ(*,*) B
CALL SOMA ( A, B, C )
WRITE(*,*) "A + B = ", C
END PROGRAM CAPITULO_12A
e) Quando h mais de um programa-fonte no projeto, primeiro deve-se compilar os programas-fonte

que contm sub-rotinas. O programa-principal deve ser compilado por ltimo.
f) Cada sub-rotina pode depender de variveis do programa-principal ou pode ser um programa
totalmente independente. Neste caso, com poucas adaptaes, um programa j existente pode ser
transformado em uma sub-rotina de um outro programa.
g) A principal vantagem de se usar sub-rotinas dividir um programa muito grande ou complexo em
unidades menores, ou subprogramas, que so mais fceis de implementar e que facilitam a
deteco de erros.
h) Cada sub-rotina deve ter um nome especfico, que definido com o comando SUBROUTINE.
Este nome usado para chamar ou usar cada sub-rotina no local desejado. As sub-rotinas so
ativadas ou chamadas atravs do comando CALL.
i) As sub-rotinas podem ser escritas pelo prprio programador ou por outros programadores, na
forma de programas-fonte ou bibliotecas.
j) Na linha PROGRAM CAPITULO_12A, do programa-fonte principal1.f90, define-se o incio e o nome
do programa-principal como sendo CAPITULO_12A. E na ltima linha, com o comando END
PROGRAM CAPITULO_12A, define-se o fim do programa-principal. O nome do programa no tem
utilidade prtica nenhuma. Deve-se perceber que ele diferente do nome do projeto e do nome do
programa-fonte.
Tabela 12.2 Programa-fonte rotina1.f90.

SUBROUTINE SOMA ( X, Y, Z )
REAL X, Y, Z
Z = X + Y
END SUBROUTINE SOMA
k) Na linha EXTERNAL ROTINA1, do programa-fonte principal1.f90, declara-se que o programa-fonte

rotina1.f90 faz parte do programa-fonte principal1.f90. Deve-se notar que no comando
EXTERNAL declarado o nome do programa-fonte que contm a sub-rotina, e no o nome da
sub-rotina.
l) Na linha CALL SOMA ( A, B, C ), do programa-fonte principal1.f90, chama-se a sub-rotina de
nome SOMA e transfere-se a ela os valores das variveis que esto entre parnteses, isto , as
variveis A, B e C, que foram declaradas como variveis reais no programa-principal.
m) Na linha SUBROUTINE SOMA ( X, Y, Z ), do programa-fonte rotina1.f90, define-se o incio e o
nome da sub-rotina como sendo SOMA e, ainda, quais as variveis que so recebidas e devolvidas
ao programa-principal, no caso as variveis X, Y e Z. E na ltima linha, com o comando END
SUBROUTINE SOMA, define-se o fim da sub-rotina SOMA.
n) As variveis de uma sub-rotina que so recebidas e devolvidas ao programa-principal so
denominadas de argumentos da sub-rotina. Elas tm que ser do mesmo tipo das variveis usadas
no programa-principal que chama a sub-rotina, mas no precisam ter o mesmo nome. No
obrigatrio que as sub-rotinas tenham argumentos.
a) No programa-principal, declarar que o programa-fonte rotina1.f90 faz parte do programa-principal
b) No programa-principal, definir as variveis A, B e C como sendo do tipo real
c) No programa-principal, ler o valor das variveis A e B
d) No programa-principal, chamar a sub-rotina SOMA, transferindo a ela os valores atuais das
variveis A, B e C

e) Na sub-rotina SOMA, receber os valores das variveis X, Y e Z, transferidos do programa-
principal
f) Na sub-rotina SOMA, realizar a soma das variveis X e Y e atribuir o resultado varivel Z
g) Na sub-rotina SOMA, ao encontrar o fim da sub-rotina, voltar ao programa-principal no ponto
onde a sub-rotina foi chamada, transferindo os valores atuais das variveis X, Y e Z, da sub-rotina,
para as variveis A, B e C do programa-principal
h) No programa-principal, escrever o valor atual da varivel C
i) No programa-principal, encerrar a execuo do programa
10) Executar Build, Compile para compilar o programa-fonte rotina1.f90.
11) Executar Build, Compile para compilar o programa-fonte principal1.f90.
Figura 12.1 Resultado do programa12a.

necessrio digitar 1, por exemplo, e, em seguida, clicar na tecla Enter.
necessrio digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, apresentado o resultado da soma das variveis A e B, calculado dentro da sub-
rotina SOMA.

14) At entender, analisar os resultados do programa12a, mostrados na Figura 12.1, considerando cada
linha dos dois programas-fonte envolvidos e as explicaes descritas nos itens 8 e 9 acima.
15) Executar novamente o programa com outros dados.
16) No Fortran, para fechar o projeto atual, executar File, Close Workspace
12.2 programa12b
1) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa12b

principal2.f90

PROGRAM CAPITULO_12B
EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL A, B, C

READ(*,*) A

READ(*,*) B
WRITE(*,*) "A + B = ", C
WRITE(*,*) "Entre com um valor inteiro para calcular seu fatorial"

READ(*,*) INTEIRO
CALL FATORIAL ( INTEIRO )
END PROGRAM CAPITULO_12B

rotinas2.f90
Tabela 12.4 Programa-fonte rotinas2.f90.

REAL X, Y, Z
Z = X + Y
END SUBROUTINE SOMA
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
WRITE(*,*) "O fatorial de", N, " eh = ", FAT
END SUBROUTINE FATORIAL
a) Implementar um programa-fonte com duas sub-rotinas
b) Utilizar duas sub-rotinas externas ao programa-principal
a) Um programa-fonte pode ser constitudo por uma ou vrias sub-rotinas. Um exemplo o
programa-fonte rotinas2.f90 que contm duas sub-rotinas.

b) Na linha CALL FATORIAL ( INTEIRO ), do programa-fonte principal2.f90, chama-se a sub-rotina
de nome FATORIAL e transfere-se a ela o valor da varivel que est entre parnteses, isto , a
varivel INTEIRO, que foi declarada como varivel do tipo inteiro no programa-principal.
a) No programa-principal, declarar que o programa-fonte rotinas2.f90 faz parte do programa-
principal
b) No programa-principal, definir as variveis A, B e C como sendo do tipo real e a varivel
INTEIRO como do tipo inteiro
c) No programa-principal, ler o valor das variveis A e B
d) No programa-principal, chamar a sub-rotina SOMA, transferindo a ela os valores atuais das
variveis A, B e C
e) Na sub-rotina SOMA, receber os valores das variveis X, Y e Z, transferidos do programa-
principal
f) Na sub-rotina SOMA, realizar a soma das variveis X e Y e atribuir o resultado varivel Z
g) Na sub-rotina SOMA, ao encontrar o fim da sub-rotina, voltar ao programa-principal no ponto
onde a sub-rotina foi chamada, transferindo os valores atuais das variveis X, Y e Z, da sub-rotina,
para as variveis A, B e C do programa-principal
h) No programa-principal, escrever o valor atual da varivel C
i) No programa-principal, ler o valor da varivel INTEIRO
j) No programa-principal, chamar a sub-rotina FATORIAL, transferindo a ela o valor atual da
varivel INTEIRO
k) Na sub-rotina FATORIAL, receber o valor da varivel N, transferido do programa-principal
l) Na sub-rotina FATORIAL, realizar o clculo do fatorial da varivel N e atribuir o resultado
varivel FAT
m) Na sub-rotina FATORIAL, escrever o valor da varivel FAT
n) Na sub-rotina FATORIAL, ao encontrar o fim da sub-rotina, voltar ao programa-principal no
ponto onde a sub-rotina foi chamada, transferindo o valor atual da varivel N, da sub-rotina, para a
varivel INTEIRO do programa-principal
o) No programa-principal, encerrar a execuo do programa
9) Executar Build, Compile para compilar o programa-fonte rotinas2.f90.
12) Ao se executar o programa, atravs de Build, Execute, obtm-se o resultado mostrado na Figura 12.2.
13) At entender, analisar os resultados do programa12b, mostrados na Figura 12.2, considerando cada
linha dos dois programas-fonte envolvidos e as explicaes descritas nos itens 7 e 8 acima.

14) Executar novamente o programa com outros dados.
Figura 12.2 Resultado do programa12b.
12.3 programa12c
1) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa12c

principal3.f90

PROGRAM CAPITULO_12C
EXTERNAL ROTINA3
CALL OUTRAS
END PROGRAM CAPITULO_12C

rotinas2.f90
mostrado na Tabela 12.4. O contedo do arquivo rotinas2.f90 tambm pode ser copiado diretamente
do projeto anterior, programa12b.
6) No Fortran, seguindo o procedimento-padro, criar e inserir no projeto o programa-fonte rotina3.f90

a) Implementar um programa com trs sub-rotinas divididas em dois programas-fonte
b) Fazer uma sub-rotina chamar outras sub-rotinas
c) Utilizar uma sub-rotina sem argumentos
Tabela 12.6 Programa-fonte rotina3.f90.

SUBROUTINE OUTRAS
EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL A, B, C

READ(*,*) A

READ(*,*) B
WRITE(*,*) "A + B = ", C

READ(*,*) INTEIRO
END SUBROUTINE OUTRAS

a) O programa12c faz exatamente o mesmo que o programa12b, da seo anterior. A diferena que
tudo o que antes era feito no programa-principal agora feito pela sub-rotina OUTRAS, que
chamada pelo programa-principal cuja nica funo dele essa chamada.
b) Uma sub-rotina pode chamar uma ou diversas sub-rotinas. Por exemplo, a sub-rotina OUTRAS
chama as sub-rotinas SOMA e FATORIAL.
10) Algoritmo do programa: o mesmo da seo 12.2, item 8.

11) Executar Build, Compile para compilar o programa-fonte rotinas2.f90.
12) Executar Build, Compile para compilar o programa-fonte rotina3.f90.
15) Ao se executar o programa, atravs de Build, Execute, obtm-se o resultado j mostrado na Figura
12.2.
16) At entender, analisar os resultados do programa12c, mostrados na Figura 12.2, considerando cada
linha dos trs programas-fonte envolvidos e as explicaes pertinentes.
12.4 programa12d
1) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa12d

principal4.f90
mostrado na Tabela 12.7. Deve-se perceber que quase todo o contedo do arquivo principal4.f90 j
foi digitado no projeto programa12c e, portanto, ele pode ser copiado dos arquivos rotinas2.f90 e
rotina3.f90.
a) Implementar um programa com sub-rotinas inseridas dentro do programa-principal
b) Utilizar sub-rotina de biblioteca
a) O programa12d praticamente idntico ao programa12c, da seo anterior. H apenas duas
diferenas. A primeira que as trs sub-rotinas (OUTRAS, SOMA e FATORIAL) que antes
estavam dentro de dois programas-fonte (rotinas2.f90 e rotina3.f90) agora esto inseridas dentro
do prprio programa-principal.
b) O comando CONTAINS do FORTRAN usado para separar o fim do programa-principal do
incio das sub-rotinas contidas dentro do programa-principal, conforme pode-se ver na Tabela
12.7.
c) A segunda diferena que, aps a chamada da sub-rotina OUTRAS, foi inserido uma chamada da
sub-rotina TDATE, que uma sub-rotina pertencente biblioteca MSIMSLMS. E, para utilizar
esta biblioteca, no incio do programa-principal foi empregado o comando USE junto com o nome
da biblioteca.

d) A biblioteca MSIMSLMS contm muitas sub-rotinas com diversas finalidades. A lista completa
das sub-rotinas desta biblioteca, informaes detalhadas e exemplos sobre cada uma delas podem
ser vistos no manual online do Fortran em: ? InfoView, IMSL Libraries Reference.
6) Algoritmo do programa: o mesmo da seo 12.2, item 8, acrescido ao final da chamada da sub-
rotina TDATE e da escrita da data corrente.

PROGRAM CAPITULO_12D
USE MSIMSLMS
INTEGER DIA, MES, ANO
CALL OUTRAS
CALL TDATE ( DIA, MES, ANO )
WRITE(*,1) DIA, MES, ANO

1 FORMAT (/, 5X, "Data de hoje eh ", I2, "/", I2, "/", I4)
CONTAINS
! -------------------------------------------------------------------
SUBROUTINE OUTRAS
INTEGER INTEIRO
REAL A, B, C

READ(*,*) A

READ(*,*) B
WRITE(*,*) "A + B = ", C

READ(*,*) INTEIRO
END SUBROUTINE OUTRAS
! -------------------------------------------------------------------
REAL X, Y, Z
Z = X + Y
END SUBROUTINE SOMA
! -------------------------------------------------------------------
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
WRITE(*,*) "O fatorial de", N, " eh = ", FAT
END SUBROUTINE FATORIAL
! -------------------------------------------------------------------
END PROGRAM CAPITULO_12D

9) Ao se executar o programa, atravs de Build, Execute, obtm-se o resultado mostrado na Figura
12.3.
10) At entender, analisar os resultados do programa12d, mostrados na Figura 12.3, considerando cada
linha do programa-fonte e as explicaes pertinentes.
Figura 12.3 Resultado do programa12d.
12.5 EXERCCIO
Exerccio 12.1
Alterar o programa12d, da seo 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 variveis 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 contedo do arquivo
criado pela sub-rotina ESCREVE. A sub-rotina ARQUIVO dever ser chamada pela sub-rotina
OUTRAS, aps a chamada da sub-rotina ESCREVE.

Captulo 13. VARIVEIS DO TIPO REAL DUPLA
Conceitos de: variveis de preciso simples e dupla, variveis do tipo real simples e dupla, mistura de
variveis do tipo inteiro com real simples e real dupla
Funes matemticas intrnsecas e formatos de edio para variveis 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 captulo, deve-se acessar o programa Fortran, no Windows
atravs de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
a) Definir uma varivel do tipo real de dupla preciso usando o comando REAL*8
b) Comparar a preciso de variveis do tipo real simples e dupla
programa13a.f90
a) No captulo 3 foram abordadas as variveis do tipo real. Elas so usadas para definir variveis do
tipo real, isto , variveis que podem guardar ou armazenar na memria do computador nmeros
reais, positivos ou negativos, como 1.0, 1.0, 1.1, 3.1416 ou 0.003. Para definir uma varivel do
tipo real num programa usa-se o comando REAL. As variveis definidas com o comando REAL
podem guardar na memria do computador valores no intervalo aproximado de 1.17e-38 a
3.40e+38 e a preciso de 6 casas decimais. Estas variveis tambm podem ser chamadas de reais
simples ou de preciso simples.
b) O novo comando REAL*8 usado para definir variveis do tipo real dupla ou de preciso dupla.
As variveis definidas com o comando REAL*8 podem guardar na memria do computador
Captulo 13. Variveis do tipo real dupla 154

valores no intervalo aproximado de 2.22e-308 a 1.79e+308 e a preciso de 15 casas decimais.
Em geral, estas variveis so mais adequadas em computao cientfica. Entretanto elas exigem o
dobro da memria computacional em relao s variveis reais simples.
c) A linha REAL A define a varivel A como sendo do tipo real simples.
d) A linha REAL*8 B define a varivel B como sendo do tipo real dupla.

REAL A
REAL*8 B
WRITE(*,*) "Entre com o valor de A (real simples) ="

READ(*,*) A
WRITE(*,*) "Entre com o valor de B (real dupla) ="

READ(*,*) B

WRITE(*,*) "Valor de B = ", B
END

8) Executar o programa, atravs de Build, Execute, com o valor 1 para as duas variveis. O resultado
deve ser o mostrado na Figura 13.1. Deve-se notar que o nmero de casas decimais da varivel A
(real simples) 6, e da varivel B (real dupla) 15.
Figura 13.1 Resultado da execuo do programa13a.f90 com A e B = 1.
9) Executar novamente o programa com o valor 123456789 para as duas variveis e analisar os
resultados.

10) Executar novamente o programa com o valor 0.001 para as duas variveis e analisar os
resultados.
11) Executar novamente o programa com o valor 1.2345678901234567890 para as duas variveis
e analisar os resultados. Notar que o algarismo da ltima casa decimal arredondado e os
algarismos excedentes so desprezados.
12) Executar novamente o programa com outros dados e analisar os resultados.
a) Usar diversas formas para definir variveis reais simples e dupla
b) Realizar clculos elementares envolvendo variveis do tipo inteiro, real simples e real dupla
programa13b.f90
a) As variveis do tipo real simples podem ser definidas atravs dos comandos REAL, REAL*4 e
REAL(4). Exemplos so as definies das variveis A, B e C.
b) As variveis do tipo real dupla podem ser definidas atravs dos comandos REAL*8, REAL(8) e
DOUBLE PRECISION. Exemplos so as definies das variveis E, F e G.
c) Os clculos das variveis D, B e C so exatamente os mesmos mostrados no programa03d.f90 do
captulo 3, seo 3.2, para explicar as conseqncias de misturar variveis do tipo inteiro e real
simples num clculo. Estas mesmas explicaes valem para as variveis reais dupla F e G.
d) Quando se atribui uma varivel real simples a uma real dupla, esta tem sua preciso deteriorada
para real simples. Um exemplo o clculo da varivel E. Isso deve sempre ser evitado. Se o
objetivo usar preciso dupla num programa, todas as variveis e os clculos devem envolver
preciso dupla, exceto em alguns tipos de clculo com variveis inteiras.
8) Executar o programa, atravs de Build, Execute, com o valor 6.9 para a varivel A.
9) Analisar os resultados mostrados na Figura 13.2. Deve-se notar a diferena de preciso no
arredondamento do clculo das variveis C e G. Tambm deve-se notar a deteriorao da preciso da

varivel real dupla E causada ao se igualar ela varivel real simples A: todos os algarismos que
aparecem na varivel E aps os zeros so lixo, tambm chamado de erro de arredondamento.

INTEGER D
REAL A
REAL*4 B
REAL(4) C
REAL*8 E
REAL(8) F
DOUBLE PRECISION G

READ(*,*) A
D = A
B = 1 / D
C = 1.0 / D
E = A
F = 1 / D
G = 1.0 / D
WRITE(*,*) "Valor de D (inteiro) = ", D
WRITE(*,*) "Valor de B (real simples) = ", B

WRITE(*,*) "Valor de C (real simples) = ", C
WRITE(*,*) "Valor de E (real dupla) = ", E

WRITE(*,*) "Valor de F (real dupla) = ", F
WRITE(*,*) "Valor de G (real dupla) = ", G
END
10) Executar novamente o programa com outros valores para a varivel A e analisar os resultados.

Figura 13.2 Resultado da execuo do programa13b.f90 com A = 6.9.
13.3 programa13c.f90
a) Mostrar a importncia de serem definidas todas as variveis de um programa
b) Utilizar o comando IMPLICIT NONE
programa13c.f90
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 varivel D no tendo sido definida,
no ocorre erro de compilao. Quando uma varivel no definida, por default, assume-se que todas
as variveis iniciadas pelas letras I at N, em ordem alfabtica, so do tipo inteiro, e as demais so do
tipo real simples.
8) Executar o programa, atravs de Build, Execute, com o valor 6.9 para a varivel A. Em princpio,
os mesmos resultados mostrados na Figura 13.2 deveriam ser obtidos. Porm, pode-se notar na
Figura 13.3 que isso no ocorre, ressaltando-se: a varivel D passou a ser uma varivel real simples;
com isso, foram alterados os valores das variveis B, C, F e G.
9) Incluir na primeira linha do programa13c.f90 o comando IMPLICIT NONE. Ele deve ser
colocado antes de qualquer declarao de tipo de varivel. Recomenda-se fortemente sempre usar o
comando IMPLICIT NONE porque ele obriga o programador a declarar explicitamente os tipos de

todas as variveis empregadas no programa. Assim, se houver a digitao errnea do nome de uma
varivel, o compilador apontar o erro.
Figura 13.3 Resultado da execuo do programa13b.f90 sem definir a varivel inteira D.
10) Executar Build, Compile para compilar a nova verso do programa. Deve-se notar que agora
ocorrer erro de compilao, apontando que a varivel D no foi declarada.
11) Incluir a declarao da varivel D como sendo do tipo inteiro, conforme mostrado na Tabela
13.3.
14) Executar o programa, atravs de Build, Execute, com o valor 6.9 para a varivel A. Agora os
resultados so os mesmos mostrados na Figura 13.2, conforme esperado.

IMPLICIT NONE
INTEGER D
REAL A
REAL*4 B
REAL(4) C
REAL*8 E
REAL(8) F
DOUBLE PRECISION G

READ(*,*) A

D = A
B = 1 / D
C = 1.0 / D
E = A
F = 1 / D
G = 1.0 / D
WRITE(*,*) "Valor de D (inteiro) = ", D
WRITE(*,*) "Valor de B (real simples) = ", B

WRITE(*,*) "Valor de C (real simples) = ", C
WRITE(*,*) "Valor de E (real dupla) = ", E

WRITE(*,*) "Valor de F (real dupla) = ", F
WRITE(*,*) "Valor de G (real dupla) = ", G
END
13.4 programa13d.f90
a) Usar funes matemticas intrnsecas do FORTRAN com variveis reais do tipo dupla
b) Usar formatos de edio com variveis reais do tipo dupla
programa13d.f90

USE PORTLIB
IMPLICIT NONE
REAL A4, B4, C4, Pi4
REAL*8 A8, B8, C8, Pi8
INTEGER VER
WRITE(*,*) "Entre com o valor de A8 (real dupla) ="

READ(*,*) A8

OPEN(9,file="saida13d.txt")
A4 = A8
WRITE(9,*) "A4 = A8 =", A4
B4 = ABS(A4)
B8 = DABS(A8)
WRITE(9,*) "B4 = Mdulo com ABS(A4) =", B4
WRITE(9,*) "B8 = Mdulo 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
WRITE(9,*) A8, "= A8 sem formato"

WRITE(9,21) A8, A8, A8, A8, A8
WRITE(9,11) A8, B8, C8
WRITE(9,12) A8, B8, C8
CLOSE(9)
VER = SYSTEM("Notepad saida13d.txt")
11 FORMAT( 5X, "A8 =", 1PE15.3, 1/, &

5X, "B8 =", 1PE15.3, 1/, &
5X, "C8 =", 1PE15.3, 1/ )
12 FORMAT ( 3(1PE10.1), "= variveis A8, B8 e C8 no formato 3(1PE10.1)" )
21 FORMAT ("A8 no formato F8.2 =", F8.2, 1/, &
"A8 no formato F5.0 =", F5.0, 1/, &
"A8 no formato E15.3 =", E15.3, 1/, &
"A8 no formato 1PE15.2 =", 1PE15.2, 1/, &
"A8 no formato 1PE15.2E3 =", 1PE15.2E3, 1/ )
END

a) Os tipos de funes matemticas intrnsecas do FORTRAN so os mesmos para variveis reais
simples ou dupla. Mas os nomes so distintos para preservar a preciso das variveis reais dupla;
em geral, acrescenta-se a letra D frente do comando usado com variveis do tipo real simples.
Por exemplo: a funo ABS(X) usada para calcular o mdulo da varivel X do tipo real simples
passa a ser DABS quando X do tipo real dupla.
b) As Tabelas 13.5 e 13.6 mostram algumas funes matemticas intrnsecas do FORTRAN para
variveis do tipo real dupla. Estas tabelas so as correspondentes s Tabelas 5.5 e 5.6 para
variveis do tipo real simples.
Tabela 13.5 Algumas funes matemticas do FORTRAN

com argumentos e resultados sendo variveis do tipo real dupla.
Mdulo ou valor absoluto Y = DABS(X)
Raiz quadrada Y = DSQRT(X)
Exponencial: Y = eX Y = DEXP(X)
Logaritmo natural Y = DLOG(X)

Logaritmo decimal Y = DLOG10(X)
Sinal Y = DSIGN(X,Z) Y = valor absoluto de X vezes o sinal de Z
Mnimo Y = DMIN1(X,Z,W) Y = valor mnimo entre X, Z e W; o
Mximo Y = DMAX1(X,Z,W) Y = valor mximo entre X, Z e W; o
c) A lista completa de funes matemticas intrnsecas 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 smbolo ?InfoView; e acessar as opes Reference, Procedures, Numeric Procedures e
as opes Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic
Procedures.
d) Os tipos de formatos de edio usados com variveis do tipo real simples tambm podem ser
usados com variveis do tipo real dupla. Estes formatos foram vistos no captulo 6, seo 6.3. Um
outro formato que pode ser conveniente 1PEX.YEZ, onde a terminao EZ indica expoente e Z
o nmero de algarismos para o expoente. Por exemplo, no programa13d.f90 usa-se o formato
1PE15.2E3.
e) Nos argumentos de funes intrnsecas para variveis do tipo real dupla deve-se definir os
nmeros usando-se a letra D (ou d) em vez de E (ou e) (das variveis reais simples) para

representar o expoente. Em clculos ou expresses que envolvam nmeros reais, tambm deve-se
fazer isso. Se estas recomendaes no forem seguidas ocorrer erro de compilao ou perda de
preciso nos clculos. Por exemplo, no programa13d.f90 usa-se 1.0e0 como argumento da
funo real simples ACOS para calcular o valor de , e 1.0d0 como argumento da funo real
dupla DACOS.
f) A escala de prioridades entre os operadores matemticos e as regras adotadas nas operaes
matemticas, descritas nas Tabelas 3.4 e 3.5 tambm se aplicam s variveis do tipo real dupla,
onde pertinente.
Tabela 13.6 Algumas funes trigonomtricas do FORTRAN

com argumentos e resultados sendo variveis do tipo real dupla.
Seno Y = DSIN(X) X em radianos
Cosseno Y = DCOS(X) X em radianos
Tangente Y = DTAN(X) X em radianos
Arco-seno Y = DASIN(X) Y em radianos
Arco-cosseno Y = DACOS(X) Y em radianos
Arco-tangente Y = DATAN(X) Y em radianos
Seno hiperblico Y = DSINH(X)
Cosseno hiperblico Y = DCOSH(X)
Tangente hiperblica Y = DTANH(X)

8) Executar o programa, atravs de Build, Execute, com o valor 1.234567890 para a varivel A8.
9) Analisar os resultados mostrados na Figura 13.4.
10) Executar novamente o programa com outros valores para a varivel A8 e analisar os
resultados; por exemplo, A8 = 1e+3, 1.0d-3, 1.2e-30.
13.5 EXERCCIOS
Exerccio 13.1
Para testar as operaes matemticas bsicas, refazer o programa03e.f90, do captulo 3, seo 3.3, usando
variveis do tipo real dupla em vez de real simples.
Exerccio 13.2
Para testar o uso da escala de prioridades entre os operadores matemticos e as regras adotadas nas
operaes matemticas, descritas nas Tabelas 3.4 e 3.5, refazer o programa03f.f90, do captulo 3, seo
3.5, usando, onde pertinente, variveis do tipo real dupla em vez de real simples.
Figura 13.4 Resultado da execuo do programa13d.f90 no arquivo saida13d.txt com A8 =

1.234567890.
Exerccio 13.3
Escrever as expresses em linguagem FORTRAN que correspondem s seguintes expresses algbricas,
onde A, B e L so nmeros reais de preciso dupla, e I e J so nmeros inteiros:

Exerccio 13.4
1) Executar o programa13d.f90 com A8 = 1.2e+308. Deve-se notar que o programa ter problema
durante a execuo. Por que isso ocorre?
2) Implementar uma nova verso do programa13d.f90 com a eliminao de tudo relacionado s variveis
reais de preciso simples.
a) Gerar o executvel desta nova verso 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
representao dos resultados atravs dos formatos usados, principalmente com relao 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.

Captulo 14. ARQUIVOS DE SADA, DE ENTRADA E INTERNOS
Conceitos de: arquivo de entrada, arquivo interno, arquivo texto, arquivo binrio, dispositivo e nome
de arquivo genricos
Comandos do FORTRAN: uso avanado de OPEN, WRITE e SYSTEM
No comando OPEN, usar os parmetros FORMATTED, UNFORMATTED, REWIND e APPEND
Para inicializar as atividades deste captulo, deve-se acessar o programa Fortran, no Windows,
1) Objetivos do programa: relembrar os conhecimentos atuais sobre

(a) o uso de janela DOS para entrar dados;
(b) escrever resultados num arquivo, com o nome do arquivo e o nmero do dispositivo sendo pr-
definidos; e
(c) abrir o arquivo de resultados com o aplicativo Notepad.
programa14a.f90
7) Executar o programa atravs de Build, Execute com o valor 8, por exemplo. O resultado deve ser o
mostrado na Figura 14.1.
8) Executar novamente o programa com outros dados e analisar os novos resultados.
9) No Fortran, para fechar o projeto atual, executar File, Close Workspace.
Captulo 14. Arquivos de sada, de entrada e internos 165

USE PORTLIB
IMPLICIT NONE
REAL*8 Pi
INTEGER UNIT, VER
Pi = DACOS(-1.0d0)
WRITE(*,*) "Entre com o valor de UNIT (inteiro) ="

READ(*,*) UNIT
OPEN(9,file="saida14a.txt")
WRITE(9,11) UNIT, Pi
CLOSE(9)
VER = SYSTEM("Notepad saida14a.txt")
11 FORMAT( 5X, "UNIT =", I4, 1/, &

5X, "Pi =", 1PE25.15 )
END
(a) Entrada de dados atravs de janela DOS;
(b) escrever resultados num arquivo cujo nome e o nmero do dispositivo so genricos e definidos
pelo usurio atravs dos dados do programa; e
(c) abrir o arquivo de resultados de nome genrico com o aplicativo Notepad.
programa14b.f90
Tabela 14.2 Programa14b.f90

USE PORTLIB
IMPLICIT NONE
REAL*8 Pi
INTEGER UNIT, VER
CHARACTER(50) SAIDA, TEXTO
Pi = DACOS(-1.0d0)
WRITE(*,*) "Unidade de saida (inteiro) ="

READ(*,*) UNIT
WRITE(*,*) "Nome do arquivo de saida (caracter) ="

READ(*,*) SAIDA
TEXTO = "Notepad " // SAIDA
OPEN(UNIT, file = SAIDA )
WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO
CLOSE(UNIT)
11 FORMAT( 1/, 5X, "UNIT =", I4, &

1/, 5X, "Pi =", 1PE25.15, &
1/, 5X, "SAIDA = ", A50, &
1/, 5X, "TEXTO = ", A50 )
VER = SYSTEM( TEXTO )
END

(a) Na linha OPEN(UNIT, file = SAIDA ), deve-se notar que no comando OPEN, no lugar do
nmero do dispositivo que identifica o arquivo, usado uma varivel chamada UNIT, que um
dado do programa. E o nome do arquivo, que aparece aps a palavra-chave FILE, tambm uma

varivel, chamada SAIDA, que definida pelo usurio atravs dos dados do programa; observa-
se que no se deve usar apstrofos ou aspas com esta varivel, como era feito antes, por exemplo
no programa14a.f90. Os nomes das variveis UNIT e SAIDA podem ser outros quaisquer.
(b) Na linha WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO, deve-se notar que no comando WRITE,
no lugar do nmero do dispositivo que identifica o arquivo, usado uma varivel chamada
UNIT, que um dado do programa.
(c) Na linha CLOSE(UNIT), deve-se notar que no comando CLOSE, no lugar do nmero do
dispositivo que identifica o arquivo, usado uma varivel 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 especfico, como era feito antes, por exemplo no programa14a.f90, usado uma varivel
chamada TEXTO.
8) Executar o programa atravs de Build, Execute com:
Unidade de sada = 8
Nome do arquivo de sada = saida.txt
Figura 14.2 Resultado do programa14b.f90 para os dados do item 8.

Unidade de sada = 9
Unidade de sada = 9
Nome do arquivo de sada = saida14b.txt

Unidade de sada = 9
Nome do arquivo de sada = saida
12) Analisar os resultados da execuo do programa com os dados dos itens 8 a 11.
13) Alterar a linha OPEN(UNIT, file = SAIDA )
para OPEN(UNIT, file = SAIDA, form = "formatted" )
Em seguida, executar novamente os itens 6 a 8, acima. O resultado deve ser o mostrado na Figura
14.2. Isso ocorre porque o parmetro FORMATTED, no comando OPEN, que aparece aps a
palavra-chave FORM, a opo default. Ou seja, usando-o ou no, o resultado o mesmo. Ele
significa que o arquivo do tipo texto, isto , ao abri-lo, consegue-se ler o contedo, principalmente
os nmeros, escritos na base decimal.
14) Alterar a linha OPEN(UNIT, file = SAIDA, form = "formatted" )
para OPEN(UNIT, file = SAIDA, form = "unformatted" )
Alterar tambm a linha WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO
para WRITE(UNIT) UNIT, Pi, SAIDA, TEXTO
Em seguida, executar novamente os itens 6 a 8, acima. O resultado deve ser o mostrado na Figura
14.3. O parmetro UNFORMATTED, no comando OPEN, que aparece aps a palavra-chave
FORM, usado para escrever resultados num arquivo do tipo binrio. Isto , ao abri-lo, no se
consegue ler o contedo, de forma geral, principalmente os nmeros, escritos na base binria. Para
escrever em forma binria, no comando WRITE deve-se indicar apenas o nmero do dispositivo do
arquivo, conforme exemplificado neste item 14. O formato binrio muito indicado para gravar
grandes quantidades de resultados, pois precisa menos espao em disco do que o formato texto.
Figura 14.3 Resultado do programa14b.f90 para o item 14.
1) Objetivo do programa: adicionar resultados num arquivo j existente.


programa14c.f90
mostrado na Tabela 14.2, que o programa14b.f90.
5) Alterar a linha OPEN(UNIT, file = SAIDA )
para OPEN(UNIT, file = SAIDA, position = "rewind" )
O parmetro REWIND, no comando OPEN, que aparece aps a palavra-chave POSITION a
opo default. Ou seja, usando-o ou no, o resultado o mesmo. Ele usado para fazer com que
resultados sejam escritos a partir do incio de um arquivo, seja o arquivo novo ou j existente.
Unidade de sada = 8
Unidade de sada = 9
O novo resultado difere do mostrado na Figura 14.2 apenas em UNIT = 9.
11) Alterar a linha OPEN(UNIT, file = SAIDA, position = "rewind" )
para OPEN(UNIT, file = SAIDA, position = "append" )
O parmetro APPEND, no comando OPEN, que aparece aps a palavra-chave POSITION usado
para fazer com que resultados sejam escritos a partir do fim de um arquivo j existente. Se o arquivo
for novo, os resultados sero escritos a partir do seu incio.
12) Executar novamente os itens 7 e 8, acima.
13) Executar novamente o item 9, acima. O resultado da execuo do programa14c.f90 deve ser o
mostrado na Figura 14.4. Deve-se perceber que ele representa a soma das execues dos itens 10 e
13.
14.4 programa14d.f90
(a) ler os dados do programa de um arquivo, em vez de usar a janela DOS; e
(b) abrir o arquivo de dados com o aplicativo Notepad.
Figura 14.4 Resultado do programa14c.f90 para o item 13.

programa14d.f90
(a) O programa14b.f90 praticamente igual ao programa14d.f90. A diferena est na forma de
entrar os dados do programa. No primeiro usada a janela DOS e, no segundo, um arquivo de
dados.
(b) Na linha OPEN(1, file = "dados.txt" ) do programa14d.f90, define-se o nmero 1 como o
dispositivo associado ao arquivo de dados chamado dados.txt.
Tabela 14.3 Programa14d.f90

USE PORTLIB
IMPLICIT NONE
REAL*8 Pi
INTEGER UNIT, VER
VER = SYSTEM("Notepad dados.txt" )
OPEN(1, file = "dados.txt" )
READ(1,*) UNIT

READ(1,*) SAIDA
CLOSE(1)
Pi = DACOS(-1.0d0)
WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO
CLOSE(UNIT)
11 FORMAT( 1/, 5X, "UNIT =", I4, &

1/, 5X, "Pi =", 1PE25.15, &
1/, 5X, "SAIDA = ", A50, &
1/, 5X, "TEXTO = ", A50 )
END
(c) Nas linhas READ(1,*) UNIT e READ(1,*) SAIDA os dois dados so lidos, variveis UNIT e
SAIDA. Deve-se notar que so dois comandos READ, cada um sendo usado para ler uma nica
varivel. Assim, aps o programa ler o contedo da varivel UNIT na primeira linha do arquivo
dados.txt, tudo que estiver nesta linha aps o valor de UNIT no considerado pelo programa.
Portanto, podem ser inseridos comentrios nos arquivos de dados para ficar claramente definido
ao que corresponde cada dado. O mesmo se aplica ao valor da varivel SAIDA na segunda linha
do arquivo dados.txt; o que est aps este dado, na mesma linha, no considerado pelo
programa.
(d) Recomenda-se sempre fazer isso: um dado por linha e, em seguida, na mesma linha, um
comentrio para informar o que significa a varivel. Alm 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 comentrios j feitos nos captulos anteriores e neste sobre o comando OPEN, para
arquivos de resultados ou de sada, tambm valem para arquivos de entrada ou de dados.

8) Antes de executar um novo programa que use arquivo de dados, necessrio criar o arquivo de dados
e inserir nele os respectivos dados. No caso do programa14d.f90, necessrio criar o arquivo
dados.txt e inserir os dois dados que correspondem s variveis UNIT e SAIDA. Para fazer
isso, executar o seguinte:
(a) Start, Programs, Accessories, Notepad
(b) Dentro do espao de edio do Notepad, editar:
8 Unidade de saida (inteiro)
saida.txt Nome do arquivo de saida (caracter)
(c) File, Save
(d) Na janela Save As, em File Name, colocar dados.txt; em Save in:, selecionar o diretrio
do projeto. Em seguida, clicar sobre o boto Save. Finalmente, selecionar File, Exit.
Figura 14.5 Arquivo de dados dados.txt do programa14d.f90.
9) Executar o programa atravs de Build, Execute. O resultado dever ser:

(a) A abertura do arquivo dados.txt com o programa Notepad. Se o arquivo no existir no
diretrio do projeto, ocorrer um erro. Se o usurio quiser, poder alterar o contedo das
variveis no arquivo dados.txt. Depois, deve-se gravar o arquivo alterado com File, Save.
Finalmente, fechar o arquivo com File, Exit.
(b) Em seguida, ocorrer a abertura do arquivo saida.txt com o programa Notepad. O contedo
dever ser o mesmo mostrado na Figura 14.2. Fechar o arquivo com File, Exit.
(c) Na janela do DOS, o resultado dever ser apenas a frase Press any key to continue
10) Executar novamente o programa atravs de Build, Execute com:
Unidade de sada = 9
Analisar o novo resultado.
11) Executar novamente o programa com outros dados e analisar o novo resultado.

14.5 programa14e.f90
1) Objetivo do programa: usar arquivos internos.

2) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome programa14e
programa14e.f90
(a) At agora o dispositivo associado a um arquivo de resultados ou de dados era explicitamente um
nmero ou uma varivel do tipo inteiro, por exemplo: a linha WRITE(9,11) UNIT, Pi do
programa14a.f90, na qual o dispositivo o nmero 9; e a linha WRITE(UNIT,11) UNIT, Pi,
SAIDA, TEXTO do programa14b.f90, na qual o dispositivo a varivel inteira UNIT. O
dispositivo associado a um arquivo de resultados ou de dados tambm pode ser uma varivel do
tipo caracter.
(b) Na linha WRITE(TEXTO2,*) UNIT do programa14e.f90, define-se a varivel TEXTO2, do tipo
caracter, como o dispositivo no qual ser escrito o contedo da varivel UNIT, que do tipo
inteiro.
(c) Na linha WRITE(TEXTO3,*) Pi do programa14e.f90, define-se a varivel TEXTO3, do tipo
caracter, como o dispositivo no qual ser escrito o contedo da varivel Pi, que do tipo real
dupla.
(d) Na linha WRITE(TEXTO4,*) TEXTO // TEXTO3 do programa14e.f90, define-se a varivel
TEXTO4, do tipo caracter, como o dispositivo no qual ser escrito o contedo da varivel
TEXTO concatenada com o contedo da varivel TEXTO3, sendo ambas do tipo caracter.
(e) Na linha READ(TEXTO3,*) TEXTO5 do programa14e.f90, define-se a varivel TEXTO3, do tipo
caracter, como o dispositivo do qual ser lido o contedo da varivel TEXTO5, que do tipo
caracter.
Tabela 14.4 Programa14e.f90

USE PORTLIB
IMPLICIT NONE
REAL*8 Pi
INTEGER UNIT, VER
CHARACTER(30) SAIDA, TEXTO, TEXTO2, TEXTO3, TEXTO5
CHARACTER(70) TEXTO4

Pi = DACOS(-1.0d0)
WRITE(*,*) "Unidade de saida (inteiro) ="

READ(*,*) UNIT
WRITE(*,*) "Nome do arquivo de saida (caracter) ="

READ(*,*) SAIDA
WRITE(TEXTO2,*) UNIT
WRITE(TEXTO3,*) Pi
WRITE(TEXTO4,*) TEXTO // TEXTO3
READ(TEXTO3,*) TEXTO5
WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO, TEXTO2, TEXTO3, TEXTO4, TEXTO5
CLOSE(UNIT)
11 FORMAT( 1/, 5X, "UNIT =", I4, &

1/, 5X, "Pi =", 1PE25.15, &
1/, 5X, "SAIDA = ", A30, &
1/, 5X, "TEXTO = ", A30, &
1/, 5X, "TEXTO2 = ", A30, &
1/, 5X, "TEXTO3 = ", A30, &
1/, 5X, "TEXTO4 = ", A70, &
1/, 5X, "TEXTO5 = ", A30 )
END

Unidade de sada = 8

Analisar o resultado.
Figura 14.6 Resultado do programa14e.f90, com o item 8.
9) Executar novamente o programa atravs de Build, Execute com outros dados. Analisar o novo
resultado.
14.6 EXERCCIOS
Exerccio 14.1
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exerccio 13.1 atendendo:
(a) um arquivo para entrar os dados do programa;
(b) no incio da execuo 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
usurio;
(d) no final da execuo do programa, abrir automaticamente o arquivo de resultados com o aplicativo
Notepad.
Exerccio 14.2
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exerccio 13.2 atendendo aos mesmos 4
itens do exerccio 14.1.

Exerccio 14.3
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exerccio 9.3 atendendo aos mesmos 4
itens do exerccio 14.1.
Exerccio 14.4
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o programa da seo 12.4, Tabela 12.7,
atendendo aos mesmos 4 itens do exerccio 14.1.
Exerccio 14.5
Implementar uma nova verso do programa14d.f90 para que:
(a) o nome do arquivo de dados seja definido pelo usurio; e
(b) no incio da execuo do programa, o arquivo de dados seja aberto automaticamente com o aplicativo
Notepad.

Captulo 15. INICIALIZAO, TEMPO DE CPU E DOS
Inicializar variveis e constantes junto com suas definies
Verses DEBUG e RELEASE de um programa-executvel
Comandos do FORTRAN: PARAMETER, Formato A<X>
Funo do FORTRAN: TIMEF
Comandos do DOS: MKDIR, COPY, ERASE, CD, RENAME, arquivo.BAT
(a) usar os novos comandos do FORTRAN: PARAMETER e formato A<X>
(b) ao definir variveis, inicializar seus valores; e
(c) escrever variveis do tipo caracter com tamanho exato de seu contedo, usando o comando
FORMAT.
programa15a.f90
USE PORTLIB
IMPLICIT NONE
INTEGER VER, X
CHARACTER(50) SAIDA, TEXTO, COMENTARIO
INTEGER :: UNIT = 20
REAL*8, PARAMETER :: Pi = 3.14159E+00
Captulo 15. Inicializao, tempo de CPU e DOS 178

VER = SYSTEM("Notepad DADOS.TXT" )
OPEN(1, file = "DADOS.TXT" )
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

(a) Na linha INTEGER :: UNIT = 20 est sendo definida a varivel UNIT como sendo do tipo
inteiro e est sendo atribudo o valor 20 a ela. Ou seja, ela est sendo inicializada com o valor
20.
(b) Na linha REAL*8, PARAMETER :: Pi = 3.14159E+00 est sendo definida a varivel Pi como
sendo do tipo real de dupla preciso, est sendo atribudo o valor 3.14159 a ela. Ou seja, ela est
sendo inicializada com o valor 3.14159. Alm disso, ela est sendo definida como uma constante
atravs do comando PARAMETER.
(c) Variveis inicializadas podem ser alteradas dentro do programa.

(d) Variveis inicializadas e definidas como constantes, com o comando PARAMETER, no podem
ser alteradas dentro do programa. Isso gera erro de compilao.
(e) Diversas variveis podem ser inicializadas numa mesma linha de programa. Basta separ-las por
vrgula.
(f) Na linha WRITE(UNIT,12) TRIM(ADJUSTL(COMENTARIO)) escreve-se a varivel
COMENTARIO no arquivo definido por UNIT, com o formato definido pelo nmero 12. O uso
das funes TRIM e ADJUSTL permite eliminar espaos em branco existentes no contedo da
varivel COMENTARIO, conforme visto no Captulo 4.
(g) Na linha 12 FORMAT( /, A<X>, " = COMENTARIO" ) o identificador A, usado para escrever
variveis do tipo caracter, est sendo usado numa forma avanada, que permite escrever
variveis do tipo caracter com o tamanho exato de seu contedo. Isto , sem espaos em branco,
que ocorrem devido ao pr-dimensionamento que necessrio fazer ao se definir uma varivel
caracter, no caso CHARACTER(50) SAIDA, TEXTO, COMENTARIO. Na sintase A<X>, X uma
varivel inteira, definida por X = LEN(TRIM(ADJUSTL(COMENTARIO))), cujo valor resulta da
aplicao da funo LEN.
8) Antes de executar o programa, necessrio criar o arquivo de dados e inserir nele os respectivos
dados. No caso do programa15a.f90, necessrio criar o arquivo DADOS.TXT e inserir os dois
dados que correspondem s variveis COMENTARIO e SAIDA. Usar, por exemplo, os dados
mostrados na Figura 15.1.
Figura 15.1 Exemplo de arquivo de dados para o programa15a.f90.
9) Executar o programa atravs 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.

(a) usar uma nova funo do FORTRAN: TIMEF; e
(b) mostrar a diferena, em termos de tempo de processamento, das verses DEBUG e RELEASE
de um programa-executvel.
Figura 15.2 Resultado do programa15a.f90 para os dados da Figura 15.1.

programa15b.f90

USE PORTLIB
IMPLICIT NONE
INTEGER VER, PASSOS, I
REAL*8 T1, T2, SOMA
READ(1,*) PASSOS
READ(1,*) SAIDA

CLOSE(1)
T1 = TIMEF()
SOMA = 0.0D0
DO I = 1, PASSOS
SOMA = SOMA + I
END DO
T2 = TIMEF()
WRITE(UNIT,11) PASSOS, SOMA, T1, T2, T2-T1

11 FORMAT( 1/, "*** PRIMEIRA SOMA ***", &
1/, 5X, "PASSOS = ", I12, &
1/, 5X, "SOMA = ", 1PE25.10E3, &
1/, 5X, "T1 (segundos) = ", 1PE25.10E3, &
1/, 5X, "T2 (segundos)= ", 1PE25.10E3, &
1/, 5X, "Tempo de CPU = T2 - T1 (segundos)= ", 1PE25.10E3 )
T1 = TIMEF()
SOMA = 0.0D0
DO I = 1, PASSOS
SOMA = SOMA + I
END DO
T2 = TIMEF()
WRITE(UNIT,12) PASSOS, SOMA, T1, T2, T2-T1

12 FORMAT( 1/, "*** SEGUNDA SOMA ***", &
1/, 5X, "PASSOS = ", I12, &
1/, 5X, "SOMA = ", 1PE25.10E3, &
1/, 5X, "T1 (segundos) = ", 1PE25.10E3, &
1/, 5X, "T2 (segundos)= ", 1PE25.10E3, &
1/, 5X, "Tempo de CPU = T2 - T1 (segundos)= ", 1PE25.10E3 )
CLOSE(UNIT)

END

(a) A funo TIMEF faz parte da biblioteca PORTLIB. Ela usada para medir o tempo de
processamento ou tempo de CPU do programa entre dois pontos desejados. O tempo de CPU o
tempo efetivamente gasto pelo processador do computador executando um programa ou parte de
um programa.
(b) A funo TIMEF mede o tempo de CPU em segundos.
(c) A funo TIMEF usada como na linha T1 = TIMEF() do programa, onde T1 deve ser uma
varivel do tipo real dupla.
(d) Dentro de um programa, a primeira chamada da funo de TIMEF zera a contagem de tempo. As
chamadas sucessivas, registram o tempo total transcorrido entre a zeragem e um ponto especfico
do programa. Desta forma, o tempo de processamento entre dois pontos igual diferena entre
os tempos registrados nestes dois pontos.
(e) Como se poder perceber nos exemplos, a funo TIMEF no tem preciso muito elevada. A
repetio de um programa pode gerar diferenas de at 0.05 segundo.
(f) No FORTRAN, a medio do tempo de processamento de um programa tambm pode ser feita
com as funes DTIME e ETIME, e a sub-rotina CPU_TIME.
(g) No FORTRAN 95, por default, uma varivel do tipo inteiro no pode ter valor maior do que 231-
1, que corresponde a 2 147 483 647, ou seja, mais de 2 bilhes.
(h) Por default, quando se compila e se gera o executvel de um programa, obtm-se a chamada
verso DEBUG. Ela til para se encontrar erros de edio ou de uso dos comandos do
FORTRAN, isto , erros de sintaxe ou erros de compilao. Mas, em termos de tempo de
processamento, a verso DEBUG mais lenta (podendo chegar a 50%) do que a verso
RELEASE. Alm disso, a verso DEBUG geralmente resulta num programa-executvel cujo
arquivo precisa de mais memria em disco do que a verso RELEASE. Para definir o tipo de
verso do programa, no menu principal do Fortran, deve-se executar Build, Set Default
Configuration..., escolher a opo desejada e clicar no boto OK. Depois, deve-se compilar e
gerar o executvel do programa.
dados. No caso do programa15b.f90, necessrio criar o arquivo DADOS.TXT e inserir os dois

dados que correspondem s variveis PASSOS e SAIDA. Usar, por exemplo, os dados
mostrados na Figura 15.3, onde PASSOS igual a 100 milhes.
9) Executar o programa atravs de Build, Execute. O resultado mostrado na Figura 15.4. Os tempos
de processamento se referem execuo do programa num microcomputador Pentium III de 750
MHz. Analisando-se o programa, deve-se perceber que os dois tempos de CPU deveriam ter
exatamente o mesmo valor, mas na Figura 15.4 nota-se que h uma diferena entre eles de 0.01 s. A
cada execuo do programa, tanto os valores do tempo de CPU quanto suas diferenas podem variar.
Figura 15.3 Exemplo de arquivo de dados para o programa15b.f90.
Figura 15.4 Resultado do programa15b.f90 para os dados da Figura 15.3, verso DEBUG.
10) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por
exemplo, PASSOS = 10 milhes, 1 milho e 1 bilho.
11) Verificar se dentro do diretrio do projeto existe um subdiretrio chamado DEBUG. Se no,
isto , se o diretrio existente for chamado RELEASE, onde se l DEBUG, nos itens 12 a 14, abaixo,
deve-se ler RELEASE e vice-versa.
12) Mudar a verso do programa para RELEASE. Para fazer isso, executar Build, Set Default
Configuration..., escolher a opo RELEASE, clicar no boto OK. Depois, executar Build,

Compile para compilar novamente o programa. Gerar o novo programa-executvel fazendo Build,
Build.
13) Verificar se dentro do diretrio do projeto tambm existe um subdiretrio chamado
RELEASE.
14) Executar o programa atravs de Build, Execute. O novo resultado mostrado na Figura 15.5.
Novamente, os dois tempos de CPU deveriam ter exatamente o mesmo valor, mas na Figura 15.5
nota-se que h uma diferena entre eles de 0.099 s. Comparando-se os tempos de processamento,
verifica-se que a verso DEBUG mais lenta cerca de 43% do que a verso RELEASE.
Figura 15.5 Resultado do programa15b.f90 para os dados da Figura 15.3, verso RELEASE.
15) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por
exemplo, PASSOS = 10 milhes, 1 milho e 1 bilho.
1) Objetivo do programa: utilizar comandos do DOS durante a execuo do programa.

programa15c.f90
mostrado na Tabela 15.3, que o programa15c.f90.

Tabela 15.3 Programa15c.f90
USE PORTLIB
IMPLICIT NONE
INTEGER DOS
CHARACTER(50) SAIDA, COMENTARIO
DOS = SYSTEM("Notepad DADOS.TXT" )
READ(1,*) COMENTARIO
READ(1,*) SAIDA
CLOSE(1)
WRITE(UNIT,11) COMENTARIO, SAIDA

11 FORMAT(1/, "COMENTARIO = ", A50, &
2/, "SAIDA = ", A50 )
CLOSE(UNIT)
! edio de comandos no arquivo EXECUTA.BAT
OPEN(UNIT, file = "EXECUTA.BAT" )
WRITE(UNIT,*) "MKDIR C:\TEMP\FORTRAN"
WRITE(UNIT,*) "COPY " // TRIM(SAIDA) // " C:\TEMP\FORTRAN\" // TRIM(SAIDA)
WRITE(UNIT,*) "ERASE " // TRIM(SAIDA)
WRITE(UNIT,*) "CD C:\TEMP\FORTRAN\"
WRITE(UNIT,*) "RENAME "// TRIM(SAIDA) // " NOVO.TXT"
CLOSE (UNIT)
! fim

DOS = SYSTEM ( "EXECUTA.BAT" )
DOS = SYSTEM( "Notepad C:\TEMP\FORTRAN\NOVO.TXT" )
END

(a) O comando do DOS chamado MKDIR usado para criar um novo diretrio. Ele usado na
forma:
MKDIR DIRETORIO
onde DIRETORIO o nome do diretrio a ser criado, incluindo o caminho completo desde a raiz
do HD (hard disk) ou disquete. Se o caminho no especificado, o diretrio criado dentro do
diretrio no qual o comando executado.
(b) O comando do DOS chamado COPY usado para copiar um arquivo em outro. Ele usado na
forma:
COPY ARQ1 ARQ2
onde ARQ1 o nome do arquivo a ser copiado em outro arquivo com o nome de ARQ2. Junto a
ARQ1 e ARQ2 deve-se definir o diretrio de cada arquivo, incluindo o caminho completo desde
a raiz do HD (hard disk) ou disquete. Se os diretrios e caminhos no so especificados, ARQ1
deve existir no diretrio no qual o comando executado, e ARQ2 gerado no mesmo diretrio.
(c) O comando do DOS chamado ERASE usado para eliminar ou deletar um arquivo. Ele usado
na forma:
ERASE ARQ
onde ARQ o nome do arquivo a ser eliminado. Junto a ARQ deve-se definir o seu diretrio,
incluindo o caminho completo desde a raiz do HD (hard disk) ou disquete. Se o diretrio e
caminho no so especificados, ARQ deve existir no diretrio no qual o comando executado.
(d) O comando do DOS chamado CD usado para mudar a execuo do programa para outro
diretrio. Ele usado na forma:
CD DIRETORIO
onde DIRETORIO o nome do diretrio para o qual passa a ser executado o programa,
incluindo o caminho completo desde a raiz do HD (hard disk) ou disquete. Subentende-se que o
diretrio existe dentro do diretrio no qual o comando executado.
(e) O comando do DOS chamado RENAME usado para mudar o nome de um arquivo. Ele usado
na forma:
RENAME ARQ1 ARQ2

onde ARQ1 o nome do arquivo existente, e ARQ2 o novo nome. Aqui valem os mesmos
comentrios para ARQ1 e ARQ2 feitos no item (b), acima.
(f) Ao se executar um arquivo com extenso .BAT, so executados todos os comandos DOS
dentro deste arquivo, linha por linha, de cima para baixo.
(g) Exemplos de aplicao dos comandos acima so apresentados no programa.
(h) Existem diversos outros comandos do DOS que podem ser empregados em funo do objetivo
desejado.
dados. No caso do programa15c.f90, necessrio criar o arquivo DADOS.TXT e inserir os dois
dados que correspondem s variveis COMENTARIO e SAIDA. Usar, por exemplo, os dados
mostrados na Figura 15.1.
(a) ocorre a abertura do arquivo DADOS.TXT
(b) so lidos os dois dados
(c) cria-se o arquivo o arquivo de sada; escreve-se nele os dois dados lidos; e fecha-se este arquivo
(d) cria-se o arquivo EXECUTA.BAT; dentro dele, so escritas diversas instrues DOS; fecha-se
este arquivo
(e) acessa-se o DOS para executar as instrues contidas no arquivo EXECUTA.BAT
(f) acessa-se o DOS para abrir, com o aplicativo Notepad, o arquivo NOVO.TXT localizado em
C:\TEMP\FORTRAN\
10) Executar o programa atravs de Build, Execute. Analisar os resultados. A Figura 15.6 mostra o
contedo do arquivo EXECUTA.BAT, gerado pelo programa15c.f90; verificar sua existncia
no diretrio do projeto. A Figura 15.7 mostra os comandos que foram executados no DOS, como
resultado da execuo do arquivo EXECUTA.BAT. A Figura 15.8 mostra o contedo do arquivo
de resultado do programa15c.f90; deve-se notar que seu nome NOVO.TXT e que ele se localiza
no diretrio C:\TEMP\FORTRAN\; verificar sua existncia; alm disso, o arquivo de sada foi
eliminado do diretrio do projeto.

Figura 15.6 Contedo do arquivo EXECUTA.BAT gerado pelo programa15c.f90.
Figura 15.7 Janela DOS resultante da execuo do programa15c.f90.
Figura 15.8 Resultado da execuo do programa15c.f90.
15.4 EXERCCIOS
Exerccio 15.1
Adaptar o programa15a.f90, Tabela 15.1, para:

(a) inicializar uma varivel do tipo caracter;
(b) inicializar uma constante do tipo caracter;
(c) inicializar duas variveis do tipo inteiro numa mesma linha de programa;
(d) inicializar duas constantes do tipo inteiro numa mesma linha de programa; e
(e) escrever num arquivo os contedos das variveis e constantes dos itens (a) a (d).
Exerccio 15.2
Adaptar o programa15b.f90, Tabela 15.2, para usar a funo DTIME junto com TIMEF e comparar o
tempo de CPU medido por cada funo.
Exerccio 15.3
Adaptar o programa15b.f90, Tabela 15.2, para que a varivel SOMA seja do tipo inteiro. Notar a reduo
do tempo de CPU que ocorre.
Exerccio 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 funo TIMEF.
Exerccio 15.5
Adaptar o programa15b.f90, Tabela 15.2, para incluir, antes da ltima chamada da funo TIMEF, a
instruo
READ(*,*) Espere alguns segundos e pressione a tecla ENTER
Analisar o efeito desta instruo vazia no tempo de CPU.
Exerccio 15.6
Adaptar o programa15c.f90, Tabela 15.3, visando generalizar o nome do diretrio
C:\TEMP\FORTRAN\
para qualquer nome que o usurio defina atravs do arquivo de dados.

Captulo 16. MEMRIA E SUB-ROTINAS 2
Estimar e verificar a memria computacional necessria para executar um programa
Utilizar sub-rotina recursiva
Controlar o fluxo de informaes para dentro e para fora de sub-rotinas
Comandos do FORTRAN: DEALLOCATE, RECURSIVE, INTENT(IN,OUT,INOUT)
(a) mostrar como estimar a memria computacional necessria para executar um programa; e
(b) usar um novo comando do FORTRAN: DEALLOCATE.
programa16a.f90
(a) O comando DEALLOCATE usado para eliminar da memria do computador variveis para as
quais foi reservado memria por meio do comando ALLOCATE. Para us-lo basta a palavra
DEALLOCATE e, dentro de parnteses, as diversas variveis separadas por vrgula. No
necessrio indicar novamente o tamanho das variveis, pois isso j conhecido do comando
ALLOCATE. O comando DEALLOCATE s pode ser usado com variveis cuja memria foi
alocada com o comando ALLOCATE.
(b) Na linha DEALLOCATE ( A ) a varivel A, do tipo inteiro, com N elementos, est sendo
eliminada da memria do computador.
(c) A estimativa da memria necessria para executar um programa pode ser obtida atravs da
Captulo 16. Memria e sub-rotinas 2 191

seguinte equao:

4 * ( N int eiro + N real simples ) + 8 * N real dupla + 1* (L * N caracter )
Memria(kB) = (16.1)
1024
onde Ninteiro, Nreal simples e Nreal dupla representam o nmero total de elementos de conjuntos ou
matrizes de variveis do tipo inteiro, real simples e real dupla, respectivamente; Ncaracter
representa o nmero total de elementos de variveis do tipo caracter que tem comprimento ou
nmero de caracteres igual a L. Dentro do ltimo parnteses devem ser includos os produtos de
outras variveis do tipo caracter com outros comprimentos. Os valores 4, 8 e 1 representam o
nmero de bytes que cada um dos tipos de variveis ocupa de memria para um nico elemento.
O valor 1024 um fator usado para converter o nmero de bytes em kilobytes (kB).

USE PORTLIB
IMPLICIT NONE
INTEGER VER, N
INTEGER, ALLOCATABLE, DIMENSION(:) :: A
REAL*8, ALLOCATABLE, DIMENSION(:) :: B
CHARACTER(10), ALLOCATABLE, DIMENSION(:) :: C
REAL*8 M1, M2, M3, M4
WRITE(*,*) "Ver memoria em uso no primeiro comando; depois clique Enter"

READ(*,*)
READ(1,*) N
READ(1,*) SAIDA
CLOSE(1)
ALLOCATE ( A(N), B(N), C(N) )
WRITE(*,*) "Ver memoria apos ALLOCATE para A, B e C"

READ(*,*)
A = 1

B = 1.0D0
C = "caracteres"
WRITE(*,*) "Ver memoria apos atribuicao de valores para A, B e C"

READ(*,*)
M1 = N*4.0 / 1024
M2 = N*8.0 / 1024
M3 = N*1.0*10 / 1024
M4 = M1 + M2 + M3
WRITE(UNIT,*) "Memoria estimada para A, inteiros (kiloBytes) = ", M1

WRITE(UNIT,*) "Memoria estimada para B, reais (kiloBytes) = ", M2
WRITE(UNIT,*) "Memoria estimada para C, caracteres (kiloBytes) = ", M3
WRITE(UNIT,*) "Memoria estimada para A, B e C (kiloBytes) = ", M4
CLOSE(UNIT)
DEALLOCATE ( A )
WRITE(*,*) "Ver memoria com B e C"

READ(*,*)
DEALLOCATE ( B )
WRITE(*,*) "Ver memoria com C"

READ(*,*)
DEALLOCATE ( C )
WRITE(*,*) "Ver memoria sem A, B e C"

READ(*,*)
END

dados. No caso do programa16a.f90, necessrio criar o arquivo DADOS.TXT e inserir os dois
dados que correspondem s variveis N e SAIDA. Usar, por exemplo, os dados mostrados na
Figura 16.1.
9) Para ver a memria efetivamente usada pelo programa, deve-se abrir o gerenciador de tarefas ou
Task Manager, executando:
(a) clicar o boto do lado direito do mouse sobre a barra de tarefas do Windows
(b) clicar o boto do lado esquerdo do mouse sobre a opo Task Manager...
(c) clicar na opo Processes do menu principal do Task Manager
Figura 16.1 Exemplo de arquivo de dados para o programa16a.f90.
10) Executar o programa atravs de Build, Execute.

11) Conforme indica a janela DOS, ver no Task Manager qual a memria inicial que o programa
est usando. Para isso, deve-se selecionar a janela do Task Manager e encontrar o processo chamado
programa16a.exe. Na linha deste processo, na ltima coluna designada por Mem Usage, indicada
a memria em kilobytes (kB) que o programa est usando no momento. Neste exemplo, deve ser de
584 kB, como mostrado na Figura 16.2. Isso significa que, mesmo sem abrir memria para variveis
do tipo conjunto, vetores ou matrizes com o comando ALLOCATE, a execuo de um programa
requer uma determinada memria. Ela necessria para guardar as instrues do programa e os
outros tipos de variveis.
12) Continuar a executar o programa16a.exe, mantendo a janela do Task Manager aberta para ver
a cada etapa do programa quanto de memria ele est usando. Deve-se perceber que:
(a) ao ser aberto o arquivo de dados com o aplicativo Notepad, a memria aumenta para 612 kB;
(b) aps a leitura dos dados e fechamento do aplicativo Notepad, a memria est em 648 kB;
(c) ao ser usado o comando ALLOCATE com as variveis A, B e C, a memria sobe para 668 kB;
isso significa que de fato no est ainda sendo usada a memria para estas variveis, a no ser
uma indicao das posies de memria que sero ocupadas;

(d) aps a atribuio de valores s variveis A, B e C a memria sobe para 22184 kB; agora, de fato,
o espao de memria aberto com o comando ALLOCATE para as variveis A, B e C est sendo
usado;
(e) aps a eliminao da varivel A, a memria cai para 18276 kB;
(f) aps a eliminao das variveis A e B, a memria cai para 10460 kB;
(g) aps a eliminao das variveis A, B e C, a memria cai para 676 kB;
(h) finalmente, quando surgir na janela DOS (Figura 16.3) a frase Press any key to continue,
significa que o programa foi encerrado e ele no ocupa mais memria alguma, como se pode ver
no Task Manager.
Figura 16.2 Memria inicial usada pelo programa16a.exe.
13) A Figura 16.4 mostra a memria estimada com a Eq. (16.1) para as variveis A, B e C do
programa16a.exe. Na Tabela 16.2 tem-se a comparao entre a memria estimada (Figura 16.4) e a
memria 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.

Figura 16.3 Janela DOS aps a execuo do programa16a.exe.
Figura 16.4 Memria estimada para executar o programa16a.exe.
Tabela 16.2 Comparao entre memria estimada e efetiva para as variveis A, B e C do

programa16a.f90.
Varivel Memria usada (kB) Memria estimada (kB) Erro %
A 3912 3906 0.15
B 7816 7812 0.05
C 9784 9766 0.18
A, B e C 21508 21484 0.11
(a) utilizar sub-rotina recursiva; e
(b) usar um novo comando do FORTRAN: RECURSIVE
programa16b.f90
(a) Em algumas aplicaes pode ser necessrio que uma sub-rotina tenha que chamar ela prpria.
Neste caso, na definio da sub-rotina necessrio usar o comando RECURSIVE antes do
nome da sub-rotina. Um exemplo dado no programa16b.f90 na linha RECURSIVE SUBROUTINE
TESTE
(b) A chamada da sub-rotina feita da forma j descrita no captulo 12, isto , usando o comando
CALL seguido do nome da sub-rotina. Um exemplo dado no programa16b.f90 na linha CALL
TESTE

PROGRAM RECURSIVO
INTEGER SOMA, K, I, MENOS
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
WRITE(*,*) "MAIN/fora do ciclo: K, SOMA, MENOS = ", K, SOMA, MENOS
CONTAINS
! -------------------------------------------------------------------
RECURSIVE SUBROUTINE TESTE
IF ( K == 1 ) THEN
WRITE(*,*) "ROTINA,IF: K=1, SOMA, MENOS = ", K, SOMA, MENOS
ELSE
SOMA = SOMA + 1

K = K - 1
WRITE(*,*) "ROTINA,ELSE: K, SOMA, MENOS = ", K, SOMA, MENOS
CALL TESTE
MENOS = MENOS - 1
WRITE(*,*) "ROTINA,APOS CALL: K, SOMA, MENOS = ", K, SOMA, MENOS
END IF
END SUBROUTINE TESTE
! -------------------------------------------------------------------
END PROGRAM RECURSIVO

(a) definies iniciais de variveis e suas atribuies
(b) no programa principal, inicia-se um ciclo para a varivel I
(c) dentro deste ciclo, chama-se a sub-rotina TESTE, do tipo recursiva
(d) dentro da sub-rotina TESTE, so executados uma condio e alguns comandos, e chama-se a
prpria sub-rotina TESTE
(e) a sub-rotina TESTE continua a chamar ela prpria at que seja satisfeita a condio
(f) em seguida, comea-se a retornar para fora da sub-rotina TESTE tantas vezes quanto ela foi
chamada por ela prpria, desde a ltima chamada at a primeira
(g) finalmente, retorna-se ao programa principal e encerra-se a sua execuo
9) Executar o programa atravs de Build, Execute. O resultado mostrado na Figura 16.5. Analisar os
resultados.
10) Alterar os valores do ciclo I e de K no programa principal. Executar novamente o programa e
analisar os novos resultados.
(a) controlar o fluxo de informaes para dentro e para fora de sub-rotinas; e
(b) usar um novo comando do FORTRAN: INTENT com parmetros IN, OUT e INOUT.

programa16c.f90
Figura 16.5 Resultado do programa16b.f90.
(a) O uso do comando IMPLICIT NONE no programa-principal obriga que sejam declaradas
explicitamente todas as variveis usadas no programa-principal e em todas as sub-rotinas do
mesmo programa. Caso contrrio, ocorrer erro de compilao.
(b) Todas as variveis definidas no programa-principal so vlidas dentro das sub-rotinas do
programa. Elas so chamadas de variveis globais. Por exemplo, as variveis A, B, C, D, E e F
do programa16c.f90, definidas na linha INTEGER A, B, C, D, E, F, so variveis globais do
programa.
(c) As variveis definidas dentro de uma sub-rotina so vlidas somente dentro da prpria sub-
rotina. Elas so chamadas de variveis locais. Seus valores ou contedos podem ser passados
para outras sub-rotinas ou para o programa-principal atravs dos argumentos da sub-rotina. Por
exemplo, as variveis R e S do programa16c.f90, definidas na linha INTEGER R, S, so
variveis locais da sub-rotina TESTE.
(d) Todas as atribuies feitas a variveis globais so reconhecidas dentro das sub-rotinas do
programa.
(e) Todas as atribuies feitas a variveis locais no so reconhecidas fora das sub-rotinas do
programa.

Tabela 16.4 Programa16c.f90
PROGRAM CAPITULO_16C
IMPLICIT NONE
INTEGER A, B, C, D, E, F
WRITE(*,*) "Entre com o valor de A (inteiro)"

READ(*,*) A
WRITE(*,*) "Entre com o valor de B (inteiro)"

READ(*,*) B
C = 100
D = A
E = B
F = A + B
WRITE(*,*) "no programa principal, antes da sub-rotina: C = 100 = ", C

WRITE(*,*) "no programa principal, antes da sub-rotina: F = A+B = ", F
CALL SOMA ( A, B, C, D, E )
WRITE(*,*) "no programa principal, depois da sub-rotina: F = 2*(A+B) = ", F

WRITE(*,*) "no programa principal, depois da sub-rotina: C = A+B = ", C
! -------------------------------------------------------------------
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

WRITE(*,*) "dentro da sub-rotina: S = 50 = ", S
WRITE(*,*) "dentro da sub-rotina: Z = C = ", Z
Z = X + Y
WRITE(*,*) "dentro da sub-rotina: Z = A+B = ", Z

WRITE(*,*) "dentro da sub-rotina: T = A = ", T
T = T + 10
R = R + 10
WRITE(*,*) "dentro da sub-rotina: T = A+10 = ", T

WRITE(*,*) "dentro da sub-rotina: R = B+10 = ", R
WRITE(*,*) "dentro da sub-rotina: F = A+B = ", F
WRITE(*,*) "dentro da sub-rotina: A = ", A
F = 2 * F
WRITE(*,*) "dentro da sub-rotina: F = 2*(A+B) = ", F
END SUBROUTINE SOMA
! -------------------------------------------------------------------
END PROGRAM CAPITULO_16C
(f) O comando INTENT usado para controlar o fluxo de informaes para dentro e para fora das
sub-rotinas. Ele usado quando se define cada varivel empregada como argumento das sub-
rotinas.
(g) O comando INTENT utilizado com trs parmetros (IN, OUT e INOUT) que definem o sentido
do fluxo da informao.
(h) O comando INTENT(IN) permite que a varivel apenas receba informao de fora da sub-rotina.
Um exemplo dado no programa16c.f90 na linha INTEGER, INTENT(IN) :: X, Y. As
variveis X e Y s podem receber informao de fora da sub-rotina TESTE. A tentativa de
atribuir valor a elas dentro da sub-rotina gerar erro de compilao. Mas elas podem ser
empregadas em expresses dentro da sub-rotina, como na linha Z = X + Y
(i) O comando INTENT(OUT) permite que a varivel apenas envie informao para fora da sub-
rotina. Um exemplo dado no programa16c.f90 na linha INTEGER, INTENT(OUT) :: Z. A
varivel Z s pode enviar informao para fora da sub-rotina TESTE.

(j) O comando INTENT(INOUT) permite que a varivel receba informao de fora da sub-rotina e
tambm que ela envie informao para fora da sub-rotina. Um exemplo dado no
programa16c.f90 na linha INTEGER, INTENT(INOUT) :: T. A varivel T pode receber e enviar
informao na sub-rotina TESTE.
(k) Quando no se usa o comando INTENT numa varivel que argumento de uma sub-rotina, por
default, assume-se implicitamente que ela foi definida como INTENT(INOUT). Um exemplo
dado no programa16c.f90 na linha INTEGER R, S, mas apenas para a varivel R, uma vez que a
varivel S no argumento da sub-rotina TESTE.
(l) Recomenda-se o uso do comando INTENT. Ele evita erros de lgica, principalmente em
programas grandes com muitas variveis.
(m) Recomenda-se usar como variveis globais apenas aquelas que so efetivamente usadas no
programa-principal. Variveis utilizadas em sub-rotinas devem ser definidas apenas nas prprias
sub-rotinas.
8) Executar o programa atravs de Build, Execute, usando por exemplo A = 1 e B = 2. O resultado
mostrado na Figura 16.6. Analisar os resultados considerando os comentrios do item 5.
9) Executar novamente o programa com outros valores para A e B, e analisar os novos resultados.
Figura 16.6 Resultado do programa16c.f90.

16.4 EXERCCIOS
Exerccio 16.1
Estimar e verificar a memria computacional necessria para usar uma matriz bidimensional, cujos
elementos so do tipo inteiro, com X1 por Y1 elementos.
Exerccio 16.2
elementos so do tipo real dupla, com X2 por Y2 elementos.
Exerccio 16.3
elementos so do tipo caracter, cada um com 100 caracteres, com X3 por Y3 elementos.
Exerccio 16.4
Juntar as matrizes dos exerccios 16.1 a 16.3 num nico programa para estimar e verificar a memria
computacional total que necessria para as trs matrizes.
Exerccio 16.5
Adaptar a sub-rotina FATORIAL, da Tabela 12.4, do captulo 12, para ser uma sub-rotina do tipo
recursiva. E implementar um programa-principal para ela.
Exerccio 16.6
Adaptar o programa12d, Tabela 12.7, do captulo 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 sada com o aplicativo
Notepad.

Exerccio 16.7
Adaptar o programa16c.f90, Tabela 16.4, deste captulo, para ter como argumentos da sub-rotina TESTE
variveis do tipo real dupla, caracteres e um conjunto unidimensional (vetor) com elementos do tipo
inteiro.

Captulo 17. MDULOS
Utilizar mdulos
Comandos do FORTRAN: MODULE, END MODULE, PRIVATE, PUBLIC
(a) exemplificar o uso e as caractersticas bsicas de mdulos em FORTRAN; e
(b) usar dois novos comandos do FORTRAN: MODULE, END MODULE.
3) No Fortran, seguindo o procedimento-padro, criar e inserir no projeto o programa-fonte dados.f90
5) No Fortran, seguindo o procedimento-padro, criar e inserir no projeto o programa-fonte saida.f90
principal.f90
(a) Um mdulo praticamente igual a um programa-principal. A maior diferena que num mdulo
no se pode ter comandos executveis antes do comando CONTAINS, ao contrrio do que
ocorre num programa-principal.
(b) A definio de mdulo em FORTRAN deve seguir a sintaxe mostrada na Tabela 17.4. O nome
do mdulo segue as regras vlidas para variveis em FORTRAN, no podendo ser igual a
nenhum outro nome de mdulo, varivel ou sub-rotina do programa. No caso de no haver sub-
Captulo 17. Mdulos 206

rotinas num mdulo, o comando CONTAINS no deve ser usado; um exemplo disso um
mdulo usado para definir as variveis globais do programa.
(c) O uso de mdulos facilita muito a estruturao de programas de grande porte prprios.
(d) Para no haver problemas com definio de variveis, deve-se usar o comando IMPLICIT
NONE dentro de cada mdulo.
(e) Um mdulo pode ser usado dentro de uma sub-rotina, de outro mdulo ou dentro de um
programa-principal atravs do comando USE seguido do nome do mdulo.
(f) Dentro de um mdulo, as variveis definidas antes do comando CONTAINS so reconhecidas
por todas as sub-rotinas do mdulo, ou seja, elas so variveis globais do mdulo onde esto
definidas.
(g) Um programa-fonte pode conter um ou vrios mdulos em seqncia.
(h) A compilao dos programas-fonte que contm mdulos deve ser feita na seguinte ordem: (1) os
mdulos que no dependem de outros; (2) os mdulos que dependem de outros; e (3) o
programa-principal.
10) Executar Build, Compile para compilar o programa-fonte dados.f90. Repetir para saida.f90 e
principal.f90, nesta ordem.
Tabela 17.1 Programa-fonte dados.f90

MODULE DADOS
IMPLICIT NONE
REAL*8 I, J
CONTAINS
SUBROUTINE LE_DADOS
WRITE(*,*) "Entre com o valor de I"

READ(*,*) I
WRITE(*,*) "Entre com o valor de J"

READ(*,*) J
END SUBROUTINE LE_DADOS
END MODULE DADOS

12) Executar o programa atravs de Build, Execute. Usar, por exemplo, os valores 1 e 2 para as
variveis I e J, respectivamente. Neste caso, os resultados da execuo devem ser os mostrados nas
Figuras 17.1 e 17.2.
13) Analisar os resultados mostrados nas Figuras 17.1 e 17.2 considerando os trs programas-fonte e os
comentrios do item 9, acima.
Tabela 17.2 Programa-fonte saida.f90

MODULE SAIDA
USE DADOS
IMPLICIT NONE
REAL*8 K
CONTAINS
SUBROUTINE CALCULOS
K = I + J
END SUBROUTINE CALCULOS
SUBROUTINE RESULTADOS
USE PORTLIB
INTEGER VER
INTEGER C
CHARACTER(20) B
B = "teste de fortran"
C = 7
OPEN(1, file = "SAIDA.TXT" )
WRITE(1,3) I, J, K
3 FORMAT( 2/, "I = ", 1PE10.3, &
2/, "J = ", 1PE10.3, &
2/, "K = ", 1PE10.3 )

WRITE(1,4) B, C
4 FORMAT(1/, 5X, A, "= B", &
2/, 5X, I5, "= C" )
CLOSE(1)
VER = SYSTEM("Notepad SAIDA.TXT" )
END SUBROUTINE RESULTADOS
END MODULE SAIDA
Tabela 17.3 Programa-fonte principal.f90

PROGRAM PROGRAMA17A
USE SAIDA
IMPLICIT NONE
CALL LE_DADOS
CALL CALCULOS
CALL RESULTADOS
WRITE(*,*) "I, J, K = ", I, J, K
END PROGRAM PROGRAMA17A
Tabela 17.4 Sintaxe de um mdulo em FORTRAN.

MODULE NOME
comandos USE e EXTERNAL
definies de variveis
CONTAINS
sub-rotinas
END MODULE NOME
1) Objetivo do programa: entender o uso de mdulos num programa composto por quatro mdulos.
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17b/
Figura 17.1 Arquivo com resultados do programa17a.exe.
Figura 17.2 Janela DOS aps a execuo do programa17a.exe.
4) Clicar com o boto do lado direito do mouse sobre o arquivo calculos.f90

8) Repetir os itens 4 a 7, acima, para os arquivos dados.f90, dados.txt, modulo.f90, resultados.f90 e
variaveis.f90
(a) Ele composto por quatro mdulos, sendo cada um editado num programa-fonte.
(b) O mdulo VARIAVEIS usado para definir todas as variveis usadas no programa.
(c) O programa-principal incorpora apenas o mdulo RESULTADOS. Mas este, tem incorporado
dentro de si o mdulo CALCULOS, que incorpora o mdulo DADOS, que finalmente incorpora

o mdulo VARIAVEIS. Assim, todos os mdulos esto tambm implicitamente inseridos dentro
do programa-principal. A ordem de compilao deve ser a inversa desta seqncia.
10) Estudar os quatro mdulos e o programa-principal considerando os comentrios do item 9 desta
seo e da anterior.
11) Executar Build, Compile para compilar o programa-fonte variaveis.f90. Repetir para dados.f90,
calculos.f90, resultados.f90 e principal.f90, nesta ordem.
13) Executar o programa atravs de Build, Execute. Usar, os dados conforme mostrado na Figura
17.3.
14) Analisar os resultados mostrados na Figuras 17.4.
Figura 17.3 Arquivo de dados do programa17b.exe.
Figura 17.4 Arquivo de resultados do programa17b.exe.

15) Executar novamente o programa usando tipo_de_calculo = 2 e analisar os novos resultados.
16) Executar novamente o programa usando tipo_de_calculo = 3 e analisar os novos resultados.
(a) definir variveis pblicas e privadas em mdulos;
(b) usar dois novos comandos do FORTRAN: PUBLIC e PRIVATE; e
(c) entender o uso de mdulos com variveis pblicas e privadas num programa-exemplo.
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17c/
4) Clicar com o boto do lado direito do mouse sobre o arquivo base.f90
8) Repetir os itens 4 a 7, acima, para os arquivos base2.f90 e main.f90
(a) Dois novos comandos do FORTRAN, associados ao uso de mdulos, so usados neste programa:
PUBLIC e PRIVATE.
(b) O comando PRIVATE empregado para definir uma varivel como privativa do mdulo no qual
ela definida. Ou seja, ela s reconhecida pelas sub-rotinas definidas dentro do prprio
mdulo. Ela no reconhecida como varivel dentro de outros mdulos ou do programa-
principal que utilizem o mdulo no qual ela est definida. Um exemplo dado na linha
integer,private :: N do mdulo PRIMEIRO: a varivel N s reconhecida como tal dentro
do mdulo PRIMEIRO; o mesmo ocorre com a varivel R. As variveis R e N do mdulo
SEGUNDO so diferentes das variveis R e N do mdulo PRIMEIRO.
(c) O comando PUBLIC empregado para definir uma varivel como global. Isto , ela
reconhecida pelas sub-rotinas definidas dentro do prprio mdulo, e tambm dentro de outros
mdulos ou do programa-principal que utilizem o mdulo no qual ela est definida. Um exemplo
dado na linha integer,public :: K do mdulo PRIMEIRO: a varivel K reconhecida
como tal dentro do mdulos PRIMEIRO e SEGUNDO, e do programa-principal.
(d) Todas as variveis definidas num mdulo antes do comando CONTAINS so assumidas como
PUBLIC, a menos que sejam explicitamente definidas como PRIVATE. Um exemplo dado na
linha integer :: L do mdulo PRIMEIRO: a varivel L entendida como PUBLIC.
(e) Mas todas as variveis definidas numa sub-rotina so assumidas como PRIVATE.
10) Estudar os dois mdulos e o programa-principal considerando os comentrios do item 9 desta
seo e da seo 17.1.
11) Executar Build, Compile para compilar o programa-fonte base.f90. Repetir para base2.f90 e
main.f90, nesta ordem.
13) Executar o programa atravs de Build, Execute. O resultado deve ser o mostrado na Figura 17.5.
14) Analisar os resultados.
Figura 17.5 Arquivo com resultados do programa17c.exe.
17.4 EXERCCIOS
Exerccio 17.1
(a) Transformar o programa12d.f90 num mdulo.
(b) Fazer o mesmo para o programa16c.f90.
(c) Criar um programa-principal para executar as rotinas destes dois mdulos.

Captulo 18. SOLUO DE SRIES E RAZES DE EQUAES
Calcular o resultado de sries infinitas
Aplicar os mtodos de iterao linear, bisseo e Newton para determinar razes de equaes
Revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot
Alterar dinamicamente arquivo de comandos do programa de grficos Wgnuplot e usar novos
comandos
(a) exemplificar o clculo do resultado de sries 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 grficos Wgnuplot e usar novos
comandos.
2) No Fortran, seguindo o procedimento-padro, 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 boto do lado direito do mouse sobre o arquivo programa18a.f90
5) Escolher a opo Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no boto OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados18a.txt, comandos18a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padro, inserir no projeto o programa-fonte
programa18a.f90, mostrado na Tabela 18.1.
10) Estudar o programa-principal considerando os comentrios do item 11, abaixo.
(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.
Captulo 18. Soluo de sries e razes de equaes 212
(c) A sub-rotina SERIE_1 usada para calcular a soma dos N termos da seguinte srie geomtrica
infinita:
(18.1)
(d) A sub-rotina SERIE_2 usada para calcular o valor de atravs da soma dos N termos da
seguinte srie infinita:
(e) A sub-rotina SERIE_3 usada para calcular o valor do nmero e atravs da soma dos N termos
da seguinte srie infinita, onde cada termo envolve a sub-rotina FATORIAL:
(f) As sub-rotinas das trs sries tambm calculam o erro para a soluo exata e escrevem no
arquivo saida18a.txt o nmero e valor de cada termo da srie, 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 comentrio para representar o ttulo do grfico de acordo
com a srie escolhida para clculo; na nona linha, escreve outro comentrio, que o comando
replot do Wgnuplot; finalmente, esta sub-rotina executa o programa Wgnuplot para fazer o
grfico semilog do erro do clculo da srie escolhida, em funo do nmero de termos N usado.
(h) O programa-principal: chama a sub-rotina DADOS; cria o arquivo saida18a.txt; escreve nele um
comentrio na primeira linha para indicar o significado de cada coluna de resultados; o smbolo
# usado para informar ao Wgnuplot que a linha apenas um comentrio, e no dados para o
grfico; dependendo do tipo de srie escolhida pelo usurio chamada a sub-rotina adequada; o
Notepad abre o arquivo de sada; e, chamada a sub-rotina para fazer o grfico do erro.
14) Executar o programa atravs de Build, Execute. Usar, os dados mostrados na Figura 18.1.

program series
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")
select case ( tipo_serie )
case ( 1 )
call serie_1
case ( 2 )
call serie_2
case ( 3 )
call serie_3
end select
close(6)
ver = system ("Notepad saida18a.txt")
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------
subroutine dados
ver = system ("Notepad dados18a.txt")
open(5,file="dados18a.txt")
read(5,*) tipo_serie
read(5,*) n
close(5)
end subroutine dados
!-------------------------------------------------
subroutine serie_1
! calcula soma de uma srie geomtrica
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
end subroutine serie_1
!-------------------------------------------------
subroutine serie_2
! calcula soma da srie de pi
exato = dacos(-1.0d0)
soma = 0
do i = 0, n
termo = 4.0d0 * ((-1)**i) / ( 2.0d0 * i + 1 )
soma = soma + termo
10 format( i8, 3(1pe30.15e3) )
end do
!-------------------------------------------------
subroutine serie_3
! calcula soma da srie de e
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
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
end subroutine fatorial
!-------------------------------------------------

subroutine grafico
integer k
open(9,file="comandos18a.gnu")
do k = 1, 7
read(9,*)
end do
select case ( tipo_serie )
case ( 1 )
write(9,*) "set title 'srie geomtrica'"
case ( 2 )
write(9,*) "set title 'srie de pi'"
case ( 3 )
write(9,*) "set title 'srie de e'"
end select
write(9,*) "replot"
close(9)
ver = system ("Wgnuplot comandos18a.gnu")
end subroutine grafico
!-------------------------------------------------
end program series
Figura 18.1 Arquivo de dados do programa18a.f90.

15) Analisar os resultados mostrados nas Figuras 18.2 e 18.3.
16) Executar novamente o programa usando tipo_serie = 2 e analisar os novos resultados.
17) Executar novamente o programa usando tipo_ serie = 3 e analisar os novos resultados.
18) Executar novamente o programa usando outros dados e analisar os novos resultados.
Figura 18.2 Parte do arquivo de resultados do programa18a.f90 para os dados da Fig. 18.1.
Figura 18.3. Grfico com resultados do programa18a.f90 para os dados da Fig. 18.1.

1) Objetivo do programa: para uma equao quadrtica especfica, aplicar os mtodos de iterao linear,
bisseo e Newton para determinar suas razes.
Fortran:
a) Clicar sobre o nome do programa-fonte.
c) Clicar dentro do campo de edio de programa-fonte.
d) File, Close.
4) Clicar com o boto do lado direito do mouse sobre o arquivo programa18b.f90
8) Repetir os itens 3 a 7, acima, para os arquivos dados18b.txt e comandos18b.gnu
9) No Fortran, seguindo o procedimento-padro, inserir no projeto o programa-fonte programa18b.f90,
(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 comentrios
da seo anterior, exceto que os arquivos envolvidos so agora dados18b.txt, comandos18b.gnu
e saida18b.txt.
(c) As sub-rotinas LINEAR, BISSECAO e NEWTON resolvem a equao
x2 5x + 6 = 0 (18.4)
atravs dos mtodos de iterao linear, bisseo e Newton para determinar suas razes. Detalhes
sobre estes mtodos podem ser encontrados na maioria dos livros de clculo numrico.
15) Analisar os resultados mostrados nas Figuras 18.5 e 18.6.

16) Executar novamente o programa usando tipo_metodo = 2 e analisar os novos resultados.
17) Executar novamente o programa usando tipo_metodo = 3 e analisar os novos resultados.
18) Executar novamente o programa usando tipo_metodo = 3, n = 20, exato = 3 e xo = 100 e analisar
os novos resultados.

program raizes
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) )
select case ( tipo_metodo )

case ( 1 )
call linear
case ( 2 )
call bissecao
case ( 3 )
call newton
end select
close(6)
ver = system ("Notepad saida18b.txt")

call grafico
!-------------------------------------------------
contains
!-------------------------------------------------
subroutine dados
ver = system ("Notepad dados18b.txt")
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
! calcula raiz de uma equao quadrtica com o mtodo da iterao linear
do i = 1, n
x = ( ( x ** 2 ) + 6 ) / 5
write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
end subroutine linear
!-------------------------------------------------
subroutine bissecao
! calcula raiz de uma equao quadrtica com o mtodo da bisseo

real*8 a, b, fa, fx
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
10 format( i8, 2(1pe30.15e3) )
end do
end subroutine bissecao
!-------------------------------------------------
subroutine newton
! calcula raiz de uma equao quadrtica com o mtodo de Newton
real*8 f, fl
do i = 1, n
f = x**2 - 5*x + 6
fl = 2*x - 5
x = x - f / fl
10 format( i8, 2(1pe30.15e3) )
end do
end subroutine newton
!-------------------------------------------------
subroutine grafico

integer k
open(9,file="comandos18b.gnu")
do k = 1, 7
read(9,*)
end do
select case ( tipo_metodo )

case ( 1 )
write(9,*) "set title 'mtodo da iterao linear'"
case ( 2 )
write(9,*) "set title 'mtodo da bisseo'"
case ( 3 )
write(9,*) "set title 'mtodo de Newton'"
end select
write(9,*) "replot"
close(9)
ver = system ("Wgnuplot comandos18b.gnu")
!-------------------------------------------------
end program raizes
Figura 18.4 Arquivo de dados do programa18b.f90.

18.3 EXERCCIOS
Exerccio 18.1
Adaptar o programa18a.f90 para incluir as seguintes opes de sries:
Figura 18.5 Parte do arquivo de resultados do programa18b.f90 para os dados da Fig. 18.4.
Exerccio 18.2
Adaptar o programa18a.f90 para usar preciso simples em todos os clculos com nmeros reais.
Comparar os resultados com a verso original do programa18a.f90 na qual usa-se preciso dupla.

Exerccio 18.3
Adaptar o programa18b.f90 para usar preciso simples em todos os clculos com nmeros reais.
Comparar os resultados com a verso original do programa18b.f90 na qual usa-se preciso dupla.
Exerccio 18.4
Adaptar o programa18b.f90 para resolver a seguinte equao:
x2 x 6 = 0 (18.9)
Figura 18.6 Grfico com resultados do programa18b.f90 para os dados da Fig. 18.4.

Captulo 19. DERIVADAS E INTEGRAIS NUMRICAS
Calcular derivadas numricas com quatro tipos de aproximaes numricas do mtodo de diferenas
finitas: UDS, DDS, CDS-2 e CDS-4.
Calcular integrais numricas com trs tipos de aproximaes numricas: regras do retngulo, trapzio
e Simpson.
1) Objetivo do programa: calcular derivadas numricas com quatro tipos de aproximaes numricas do
mtodo de diferenas finitas: UDS, DDS, CDS-2 e CDS-4.
2) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome projeto_19
8) Repetir os itens 3 a 7, acima, para os arquivos dados19a.txt, comandos19a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padro, inserir no projeto o programa-fonte
programa19a.f90, mostrado na Tabela 19.1.
(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 numrica da funo f = ex com
quatro tipos de aproximaes numricas do mtodo de diferenas finitas:
Captulo 19. Derivadas e integrais numricas 226

onde h = x, intervalo em x usado para aproximar cada derivada. Esta sub-rotina tambm calcula
o erro de cada uma das quatro aproximaes numricas em relao soluo analtica da
derivada que ex.
(d) A sub-rotina POTENCIA usada para calcular a derivada numrica da funo f = x5 com os
quatro tipos de aproximaes numricas das Eqs. (19.1) a (19.4). Esta sub-rotina tambm calcula
o erro de cada uma das quatro aproximaes numricas em relao soluo analtica 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 comentrio para representar o ttulo do grfico de acordo
com a funo escolhida para calcular a derivada. E na linha seguinte, escreve outro comentrio,
que o comando replot do Wgnuplot. Finalmente, esta sub-rotina executa o programa Wgnuplot
para fazer o grfico log-log do erro do clculo da derivada da funo escolhida, para cada uma
das quatro aproximaes numricas, em funo do nmero de refinos de h definido nos dados do
programa.
(f) O programa-principal: (1) define suas variveis globais; (2) chama a sub-rotina DADOS; (3) cria
o arquivo saida19a.txt; (4) escreve nele um comentrio na primeira linha para indicar o
significado de cada coluna de resultados (o smbolo # usado para informar ao Wgnuplot que a
linha apenas um comentrio, e no dados para o grfico); (5) dependendo do tipo de funo
escolhida pelo usurio, chamada a sub-rotina adequada; (6) o Notepad abre o arquivo de sada;
e, (7) chamada a sub-rotina para fazer o grfico dos erros com os comandos mostrados na
Figura 19.1.

program derivadas
use portlib
implicit none
integer :: i ! nmero da aproximao de cada delta

integer :: L ! nmero de refinos de hmax
integer :: ver ! auxlio de System
integer :: tipo_funcao ! tipo de funo a derivar
real*8 :: hmax ! maior delta

real*8 :: r ! razo de refino dos deltas
real*8 :: X ! coordenada para calcular a derivada
real*8 :: exato ! soluo analtica da derivada
call dados ! l os dados do programa

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)")
select case ( tipo_funcao )

case ( 1 )
call exponencial
case ( 2 )
call potencia
end select
close(6)
ver = system ("Notepad saida19a.txt")
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------

subroutine dados
ver = system ("Notepad dados19a.txt")
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
! calcula a derivada da exponencial de X
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)

fl_CDS4 = ( 8*fe - 8*fw + fww - fee ) / (12 * h)
write(6,10) h, dabs(exato-fl_UDS), dabs(exato-fl_DDS), &

dabs(exato-fl_CDS2), dabs(exato-fl_CDS4)
10 format( 5(1pe15.5) )
end do
end subroutine exponencial
!-------------------------------------------------
subroutine potencia
real*8 :: xw, h, fp, fw, fl_UDS, fl_DDS, xe, fe, fl_CDS2, &
xww, xee, fww, fee, fl_CDS4
! calcula a derivada de X**5

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)
write(6,10) h, dabs(exato-fl_UDS), dabs(exato-fl_DDS), &

dabs(exato-fl_CDS2), dabs(exato-fl_CDS4)

10 format( 5(1pe15.5) )
end do
end subroutine potencia
!-------------------------------------------------
subroutine grafico
integer k
open(9,file="comandos19a.gnu")
do k = 1, 12
read(9,*)
end do

case ( 1 )
write(9,*) "set title 'derivada de exponencial(X)'"
case ( 2 )
write(9,*) "set title 'derivada de X**5'"
end select
write(9,*) "replot"
close(9)
ver = system ("Wgnuplot comandos19a.gnu")

!-------------------------------------------------
end program derivadas
15) Analisar os resultados mostrados nas Figuras 19.3 e 19.4. Exceto nos maiores valores de h, as
aproximaes UDS e DDS apresentam quase os mesmos valores de erro. Conforme previsto pela
teoria, as aproximaes CDS-2 e CDS-4 apresentam os menores valores de erro para um mesmo h.
Teoricamente, o erro de cada aproximao deveria sempre se reduzir com a reduo de h, e deveria

atingir o valor nulo para h = 0. Porm, na prtica, os erros de arredondamento impem um limite
mnimo ao erro de cada aproximao, como mostrado na Figura 19.4 para o CDS-2 e CDS-4.
16) Executar novamente o programa usando X = 10 e analisar os novos resultados.
17) Executar novamente o programa usando X = 0.1 e analisar os novos resultados.
18) Executar novamente o programa usando tipo de funo = 2 e analisar os novos resultados.
Figura 19.1 Arquivo de comandos para o aplicativo Wgnuplot do programa19a.f90.
Figura 19.3 Arquivo de resultados do programa19a.f90 para os dados da Fig. 19.2.

1) Objetivo do programa: calcular integrais numricas com trs tipos de aproximaes numricas:
regras do retngulo, trapzio e Simpson.
Fortran:
a) Clicar sobre o nome do programa-fonte.
c) Clicar dentro do campo de edio de programa-fonte.
d) File, Close.
4) Clicar com o boto do lado direito do mouse sobre o arquivo programa19b.f90
8) Repetir os itens 3 a 7, acima, para os arquivos dados19b.txt e comandos19b.gnu
9) No Fortran, seguindo o procedimento-padro, inserir no projeto o programa-fonte programa19b.f90,

program integrais
use portlib
implicit none
integer :: i ! nmero do refino dos elementos de integrao

integer :: j ! nmero do elemento de integrao
integer :: Nmin ! nmero mnimo de elementos de integrao
integer :: L ! nmero de refinos de elementos de integrao
integer :: r ! razo de aumento de elementos de integrao
integer :: ver ! auxlio de System
integer :: tipo_funcao ! tipo de funo a derivar
real*8 :: h ! tamanho dos elementos de integrao

real*8 :: exato ! soluo analtica da derivada
call dados ! l os dados do programa
open(6,file="saida19b.txt") !
write(6,10)
10 format("#", t5,"h", t20,"E(retngulo)", t35,"E(trapzio)", t50,"E(simpson)")

case ( 1 )
call exponencial
case ( 2 )
call potencia
end select
close(6)
ver = system ("Notepad saida19b.txt")
call grafico
!-------------------------------------------------
contains
!-------------------------------------------------

subroutine dados
ver = system ("Notepad dados19b.txt")
open(5,file="dados19b.txt")
read(5,*) tipo_funcao
read(5,*) Nmin
read(5,*) r
read(5,*) L
close(5)
!-------------------------------------------------
subroutine exponencial
real*8 :: xp, fp, ret, trap, xw, fw, simp, xe, fe
! calcula a integral da exponencial de X entre 0 e 1
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

simp = 0.0d0
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
write(6,10) h, dabs(exato-ret), dabs(exato-trap), dabs(exato-simp)
10 format( 4(1pe15.5) )
end do
end subroutine exponencial
!-------------------------------------------------
subroutine potencia
real*8 :: xp, fp, ret, trap, xw, fw, simp, xe, fe
! calcula a integral de X**5 entre 0 e 1
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)

fp = xp**5
ret = ret + fp * h
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
write(6,10) h, dabs(exato-ret), dabs(exato-trap), dabs(exato-simp)
10 format( 4(1pe15.5) )
end do
end subroutine potencia
!-------------------------------------------------
subroutine grafico
integer k
open(9,file="comandos19b.gnu")
do k = 1, 11
read(9,*)
end do

case ( 1 )
write(9,*) "set title 'integral de exponencial(X) entre 0 e 1'"
case ( 2 )
write(9,*) "set title 'integral de X**5 entre 0 e 1'"
end select
write(9,*) "replot"
close(9)
ver = system ("Wgnuplot comandos19b.gnu")
!-------------------------------------------------
end program integrais

(a) O programa19b.f90 composto pelo programa-principal e quatro sub-rotinas.
(b) A sub-rotina DADOS usada para ler os dados do programa do arquivo dados19b.txt.
(c) A sub-rotina EXPONENCIAL usada para calcular a integral numrica da funo f = ex com trs
tipos de aproximaes numricas:

onde xk = h*k. Esta sub-rotina tambm calcula o erro de cada uma das trs aproximaes
numricas em relao soluo analtica da integral que e-1.
(d) A sub-rotina POTENCIA usada para calcular a integral numrica da funo f = x5 com os trs
tipos de aproximaes numricas das Eqs. (19.5) a (19.7). Esta sub-rotina tambm calcula o erro
de cada uma das trs aproximaes numricas em relao soluo analtica da integral que 1/6.
(e) A sub-rotina GRAFICO abre o arquivo comandos19b.gnu e desce as primeiras onze linhas deste
arquivo. Na linha seguinte, escreve um comentrio para representar o ttulo do grfico de acordo
com a funo escolhida para calcular a integral. E na linha seguinte, escreve outro comentrio,
que o comando replot do Wgnuplot. Finalmente, esta sub-rotina executa o programa Wgnuplot
para fazer o grfico log-log do erro do clculo da integral da funo escolhida, para cada uma das
trs aproximaes numricas, em funo do nmero (N) de intervalos (h) de integrao definido
com os dados do programa.
(f) O programa-principal: (1) define suas variveis globais; (2) chama a sub-rotina DADOS; (3) cria
o arquivo saida19b.txt; (4) escreve nele um comentrio na primeira linha para indicar o
significado de cada coluna de resultados (o smbolo # usado para informar ao Wgnuplot que a
linha apenas um comentrio, e no dados para o grfico); (5) dependendo do tipo de funo
escolhida pelo usurio, chamada a sub-rotina adequada; (6) o Notepad abre o arquivo de sada;
e, (7) chamada a sub-rotina para fazer o grfico dos erros com os comandos mostrados na Figura
19.5.
Figura 19.5 Arquivo de comandos para o aplicativo Wgnuplot do programa19b.f90.

15) Analisar os resultados mostrados nas Figuras 19.7 e 19.8. Conforme previsto pela teoria, as
aproximaes das regras do retngulo e trapzio devem ter erros similares, enquanto que o erro da

regra de Simpson deve ser o menor, para um mesmo h. Teoricamente, o erro de cada aproximao
deveria sempre se reduzir com a reduo de h, e deveria atingir o valor nulo para h = 0. Porm, na
prtica, os erros de arredondamento impem um limite mnimo ao erro de cada aproximao, como
mostrado na Figura 19.8 para a regra de Simpson.
16) Executar novamente o programa usando tipo de funo = 1 e analisar os novos resultados.
Figura 19.6 Arquivo de dados do programa19b.f90.
Figura 19.7 Arquivo de resultados do programa19b.f90 para os dados da Fig. 19.6.
19.3 EXERCCIOS
Exerccio 19.1
Acrescentar uma sub-rotina no programa19a.f90 para calcular a derivada de f = 3ex. Incluir a nova opo
de funo no arquivo de dados e no programa. Apresentar arquivo com o erro dos quatro tipos de
aproximaes e respectivo grfico.

Exerccio 19.2
Acrescentar uma sub-rotina no programa19a.f90 para calcular a derivada de f = x4. Incluir a nova opo
de funo no arquivo de dados e no programa. Apresentar arquivo com o erro dos quatro tipos de
Figura 19.8. Grfico com resultados do programa19b.f90 para os dados da Fig. 19.6.
Exerccio 19.3
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = 3ex. Incluir a nova opo
de funo no arquivo de dados e no programa. Apresentar arquivo com o erro dos trs tipos de
Exerccio 19.4
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = x4. Incluir a nova opo de
funo no arquivo de dados e no programa. Apresentar arquivo com o erro dos trs tipos de aproximaes
e respectivo grfico.

Captulo 20. SOLUO DE SISTEMAS DE EQUAES
Aplicar, num nico programa, diversos recursos e comandos do FORTRAN vistos nos captulos
anteriores.
Resolver sistemas de equaes lineares com mtodos diretos e iterativos.
1) Objetivo do programa: resolver um problema de conduo de calor unidimensional permanente

atravs de simulao numrica com o mtodo de diferenas finitas. A soluo dos sistemas de
equaes lineares do problema obtida com mtodos diretos e iterativos.
2) No Fortran, seguindo o procedimento-padro, criar um projeto com o nome projeto_20a
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_20a
8) Repetir os itens 3 a 7, acima, para os arquivos variaveis.f90, solvers_1D.f90, dados.f90,
coeficientes.f90, resultados.f90, programa20a.ent, comandos20a.gnu e Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padro, inserir no projeto o programa-fonte variaveis.f90,
10) Repetir o item 9 para os programas-fonte: solvers_1D.f90 (Tabela 20.2), dados.f90 (Tabela 20.3),
coeficientes.f90 (Tabela 20.4), resultados.f90 (Tabela 20.5) e programa20a.f90 (Tabela 20.6).
(a) O programa20a.f90 composto pelo programa-principal e cinco mdulos, editados em seis
programas-fonte diferentes.
(b) No mdulo VARIAVEIS, contido no programa-fonte variaveis.f90, so definidas as variveis
Captulo 20. Soluo de sistemas de equaes 243

globais do programa. Este mdulo no contm nenhuma sub-rotina.
(c) O mdulo SOLVERS_1D, contido no programa-fonte solvers_1D.f90, dedicado soluo de

sistemas de equaes lineares do tipo
AT = B (20.1)
originados de problemas unidimensionais. A a matriz de coeficientes, T o vetor incgnita e B

o vetor dos termos independentes. A dimenso de A NxN, e de T e B, Nx1, onde N o
nmero de incgnitas (T) do problema. Este mdulo contm quatro sub-rotinas. Trs delas so
mtodos para resolver sistemas de equaes. O mtodo de eliminao de Gauss resolve uma
matriz A do tipo cheia de forma direta. O mtodo de Gauss-Seidel resolve uma matriz A do tipo
cheia mas de forma iterativa. Neste programa-exemplo, os mtodos eliminao de Gauss e
Gauss-Seidel esto adaptados para resolver uma matriz A do tipo tridiagonal, isto , apenas trs
diagonais da matriz A tm valores no-nulos. Finalmente o mtodo TDMA (Tri-Diagonal Matrix
Algorithm) resolve uma matriz A do tipo tridiagonal de forma direta. Alm disso, existe uma
rotina que calcula a norma l1 mdia do resduo das equaes do sistema, definido por
R = B AT (20.2)
O valor da norma usado para comparar com uma tolerncia especificada pelo usurio visando
interromper o processo iterativo do mtodo de Gauss-Seidel.
(d) O mdulo 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 sada de nome genrico.
(e) O mdulo 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 equaes das N variveis T. So definidos os valores dos coeficientes apenas em trs
diagonais da matriz A. Isso ocorre porque estes coeficientes so originados da discretizao de
uma equao diferencial que modela a conduo de calor unidimensional em regime
permanente; e a aproximao usada, do mtodo de diferenas finitas, a diferena central de 2
ordem, CDS-2, vista no captulo 19. O valor de B depende da definio do usurio no arquivo de
dados, gerando valores nulos ou no-nulos. A outra sub-rotina usada para escrever os valores
dos coeficientes e do termo independente num arquivo de sada de nome genrico.
(f) O mdulo RESULTADOS, contido no programa-fonte resultados.f90, tambm tem duas sub-
rotinas. A primeira usada para: (1) chamar a sub-rotina de clculo de coeficientes e termos
independentes; (2) escrever os coeficientes; (3) resolver a Eq. (20.1) com um dos trs mtodos
disponveis, de acordo com a escolha do usurio no arquivo de dados; (4) cronometrar o tempo
de CPU; (5) chamar a segunda sub-rotina do mdulo; e (6) escrever o tempo de CPU num
arquivo de sada de nome genrico. A segunda sub-rotina deste mdulo usada para: (1) criar o
arquivo T.dat; (2) escrever neste arquivo a soluo analtica e numrica de T, e seu erro; (3)
escrever um ttulo no arquivo comandos20a.gnu; e (4) chamar o aplicativo Wgnuplot para fazer
o grfico de T com os comandos mostrados na Figura 20.1.
(g) O programa-principal: (1) apresenta comentrios descrevendo um resumo das caractersticas do
programa; (2) obtm a data e a hora do sistema operacional; (3) chama a sub-rotina de leitura dos
dados do programa; (4) cria o arquivo de sada de nome genrico; (5) escreve nele o ttulo da
simulao, a data e hora; (6) faz a alocao de memria; (7) calcula a coordenada X
correspondente a T em N pontos; (8) chama a sub-rotina que escreve os dados; (9) chama a sub-
rotina que resolve a Eq. (20.1); (10) com o aplicativo Notepad, mostra o contedo do arquivo de
sada.
(h) Os campos de coeficientes, T e grfico so escritos com uma freqncia (w) definida pelo
usurio.
Tabela 20.1 Variaveis.f90

module variveis
use portlib
implicit none
integer :: N ! nmero total de ns
integer :: i ! nmero do n
! i = 1, n no contorno esquerdo
! i = N, n no contorno direito
! 2 <= i <= N-1, ns internos
integer :: matriz ! tipo de matriz: 1 = sem fonte; 2 = com fonte
integer :: solver ! tipo de solver: 1 = Eliminao de Gauss (EG)

! 2 = Gauss-Seidel (GS)
! 3 = TDMA integer ::
iteracao ! nmero de iteraes para o GS integer :: w
! freqncia de escrita de resultados

real*8 :: Tol ! tolerncia sobre resduo para o GS
real*8 :: tcpu ! tempo de CPU em segundos integer :: ver
! auxlio do comando System real*8,dimension(:),allocatable :: T
! soluo numrica real*8,dimension(:),allocatable :: x !
coordenada espacial nodal real*8,dimension(:),allocatable :: aP !
coeficiente central de u
real*8,dimension(:),allocatable :: aW ! coeficiente esquerdo de u
real*8,dimension(:),allocatable :: aE ! coeficiente direito de u
real*8,dimension(:),allocatable :: bP ! termo fonte de u
character*20 :: caso ! nome do arquivo de sada
character*50 :: title ! ttulo do grfico

character*62 :: head ! ttulo do grfico + dia
character*12 :: dia ! data da simulao

character*8 :: hora ! horrio da simulao
integer*4 :: var(8) ! data e hora
character*20 :: vardate ! data e hora
character*20 :: vartime ! data e hora
character*20 :: varzone ! data e hora
character*70 :: note_caso ! notepad + caso
character*2 :: aux1,aux2
character*4 :: aux3
character*50 :: aux
end
Tabela 20.2 Solvers_1D.f90

module solvers_1D
! objetivo: resolver sistema linear de equaes algbricas

! originado de problemas unidimensionais
use variaveis

implicit none
contains
!-------------------------------------------------
! Mtodo direto eliminao de Gauss
subroutine EG (N,ap,b,c,d,T)
implicit none
integer :: ii, j
real*8 :: mji, S
integer,intent(in) :: N ! nmero de ns
real*8,dimension(:,:),allocatable :: A ! matriz de coeficientes
real*8,intent(in), dimension(N) :: ap ! coeficiente aP

real*8,intent(in), dimension(N) :: b ! coeficiente aW
real*8,intent(in), dimension(N) :: c ! coeficiente aE
real*8,intent(in), dimension(N) :: d ! termo fonte bP
real*8,intent(out),dimension(N) :: T ! incgnita
allocate ( A(N,N+1) )
A = 0.0d0
! gera a matriz de coeficientes A com o termo independente
do i = 1,N
if (i > 1) A(i,i-1) = -b(i)
A(i,i) = ap(i)
if (i < N) A(i,i+1) = -c(i)
A(i,N+1) = d(i)

end do
! Escalonamento
do i = 1,N-1
do ii = i+1,N
mji= A(ii,i) / A(i,i)
do j = i,N+1
A(ii,j) = A(ii,j) - mji*A(i,j)
end do
end do
end do
!Substituicao retroativa
T(N) = A(N,N+1) / A(N,N)
do i = N-1,1,-1
S = 0
do j = i+1,N
S = S + A(i,j)*T(j)
end do
T(i) = (A(i,N+1) - S) / A(i,i)
end do
deallocate ( A )
end subroutine EG

!-------------------------------------------------
! mtodo iterativo de Gauss-Seidel
subroutine GS (N,ite,tol,a,b,c,d,T)
implicit none
integer :: it ! nmero da iterao
integer :: ite ! nmero de iteraes
real*8, intent(in) :: Tol ! tolerncia sobre R
real*8,intent(in), dimension(N) :: a ! coeficiente aP

real*8 :: R ! norma l1 mdia dos resduos
T = 0.0d0
do it = 1, ite
T(1) = ( c(1)*T(2) + d(1) ) / a(1)
do i = 2, N-1
T(i) = ( b(i)*T(i-1) + c(i)*T(i+1) + d(i) ) / a(i)
end do
T(N) = ( b(N)*T(N-1) + d(N) ) / a(N)
call norma (N,a,b,c,d,T,R)
if ( R <= Tol ) then

write(10,1) it, Tol, R

1 format(//, 'O processo iterativo convergiu em', I8, ' iteraes', &
/, 'para a tolerncia de', 1pe10.2, &
/, 'A norma l1 mdia dos resduos ', 1pe10.2, /)
exit
end if
end do
if ( R > Tol ) then

write(10,2) ite, Tol, R
2 format(//, 'O processo iterativo NO convergiu em', I8, ' iteraes', &
/, 'para a tolerncia de', 1pe10.2, &
/, 'A norma l1 mdia dos resduos ', 1pe10.2, /)
end if
end subroutine GS
!-------------------------------------------------
! calcula a norma l1 mdia do resduo das equaes
subroutine norma (N,a,b,c,d,T,R)
implicit none
integer :: i ! nmero do n integer,intent(in) :: N !
nmero de ns real*8,intent(in), dimension(N) :: a !
coeficiente aP
real*8,intent(inout) :: R ! norma l1 mdia dos resduos
R = 0.0d0
R = R + dabs ( c(1)*T(2) + d(1) - T(1)*a(1) )
do i = 2, N-1

R = R + dabs ( b(i)*T(i-1) + c(i)*T(i+1) + d(i) - T(i)*a(i) )
end do
R = R + dabs ( b(N)*T(N-1) + d(N) - T(N)*a(N) )
R = R / N
end subroutine norma
!-------------------------------------------------
! mtodo direto Tri-Diagonal Matrix Algorithm (TDMA)
subroutine TDMA (N,a,b,c,d,T)
implicit none
real*8 :: div ! varivel auxiliar
real*8,dimension(:),allocatable :: P ! coeficiente do tdma

real*8,dimension(:),allocatable :: Q ! coeficiente do tdma
real*8,intent(in), dimension(N) :: a ! coeficiente aP

allocate(P(N),Q(N))
P(1) = c(1) / a(1)

Q(1) = d(1) / a(1)
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

end do
T(N) = Q(N)
do i = N-1, 1, -1
T(i) = P(i)*T(i+1) + Q(i)
end do
deallocate(P,Q)
end subroutine tdma
!-------------------------------------------------
end module solvers_1D
Tabela 20.3 Dados.f90

module dados
! objetivo: ler e escrever os dados
use variaveis
!-------------------------------------------------
implicit none
contains
!-------------------------------------------------
subroutine le_dados
ver = system('notepad programa20a.ent') ! lista dados
open(7,file='programa20a.ent')
read(7,*) caso
read(7,*) N
read(7,*) matriz
read(7,*) solver
read(7,*) iteracao

read(7,*) Tol
read(7,*) w
read(7,*) title
close(7)
end subroutine le_dados
!-------------------------------------------------
subroutine mostra_dados
integer :: comp
comp = len(trim(adjustl(caso)))
write(10,1) trim(adjustl(caso)), N, matriz, solver, iteracao, Tol
1 format(/,5x,'DADOS',//, &
a<comp>,' = caso',/, &
i6,' = nmero de ns',/, &
i6,' = tipo de matriz: 1 = fonte nulo; 2 = fonte no-nulo',/, &
i6,' = tipo de solver: 1=El.Gauss; 2=GS; 3=TDMA',/, &
i6,' = nmero de iteraes para o GS',/, &
1pe10.2,' = tolerncia sobre o resduo para o GS')
end subroutine mostra_dados
!-------------------------------------------------
end module dados
Tabela 20.4 Coeficientes.f90

module coeficientes
! objetivo: calcular os coeficientes e termos fontes

! das equaes discretizadas
use dados
implicit none

contains
!-------------------------------------------------
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))
end subroutine lista_coeficientes
!-------------------------------------------------
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
select case ( matriz )

case ( 1 ) ! fonte nulo
bP = 0.0d0
case ( 2 ) ! fonte no-nulo
bP = - 2.0d0 / ( (N-1)**2 )
end select
! contorno esquerdo
aw(1) = 0.0d0
ae(1) = 0.0d0
aP(1) = 1.0d0
bP(1) = 0.0d0

! contorno direito
aw(N) = 0.0d0
ae(N) = 0.0d0
aP(N) = 1.0d0
bP(N) = 1.0d0
end subroutine coeficientes_e_fontes
!-------------------------------------------------
end module coeficientes
Tabela 20.5 Resultados.f90

module resultados
! objetivo: calcular soluo numrica e

! apresentar grficos dos resultados
!-------------------------------------------------
use coeficientes
use solvers_1D
implicit none
contains
! -----------------------------------------------
subroutine solucao_numerica
! clculo dos coeficientes e termos fontes

call coeficientes_e_fontes
! escrita dos coeficientes e termos fontes

call lista_coeficientes
tcpu = timef() ! zera cronmetro
! soluo do sistema de equaes
select case ( solver )

case ( 1 ) ! Eliminao de Gauss
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
call tdma (N,aP,aw,ae,bP,T)
end select
tcpu = timef()
! escrita da varivel primria e sua visualizao

call escreve_T
write(10,1) tcpu
1 format(/, f14.3, ' = tempo de processamento (segundos)')
end subroutine solucao_numerica
!-------------------------------------------------
subroutine escreve_T
real*8 :: T_exato ! auxiliar

integer :: j ! auxiliar
! abertura de arquivo para gravar resultados de T (analtico e numrico)

open(7,file='T.dat')
write(10,1)
1 format(/,t4,'X',t28,'T (analtico)',t52,'T (numrico)',t76,'erro',/)
do i = 1, N
select case ( matriz )

case ( 1 ) ! fonte nulo
T_exato = (i-1.0d0) / (N-1)

case ( 2 ) ! fonte no-nulo
T_exato = ( (i-1.0d0) / (N-1) ) ** 2
end select
if ( i==1 .or. i==n .or. mod(i,w)==0 ) then

write( 7,2) X(i), T_exato, T(i), T_exato - T(i)
write(10,2) X(i), T_exato, T(i), T_exato - T(i)
2 format(4(1pe24.15))
end if
end do
close(7)
! adapta arquivo de comandos para fazer grfico

open(7,file='comandos20a.gnu')
do j = 1, 8
read(7,*)
end do
write(7,3) head
3 format("set title '",a62,/,"replot")
close(7)
! mostra o grfico de T
ver = system('wgnuplot comandos20a.gnu')
end subroutine escreve_T
!-------------------------------------------------
end module resultados
program programa20a
! Difuso de calor unidimensional permanente
! Verso original 1.0 (25 Mai 07)

! Verso atual 1.0 (25 Mai 07)
! ltima alterao = 26 Mai 07

! autor: Carlos Henrique Marchi (Curitiba, DEMEC/UFPR)
! MODELO MATEMTICO (resumo)

! Equao diferencial: d2T/dx2 = S
! Condio de contorno de Dirichlet em x = 0: T(0) = 0
! Condio de contorno de Dirichlet em x = 1: T(1) = 1
! x = coordenada espacial (varivel independente)
! T = temperatura (varivel dependente)
! S = termo fonte
! Soluo analtica conhecida da equao diferencial
! Soluo analtica conhecida da equao discretizada
! MODELO NUMRICO (resumo)

! Incgnita (varivel primria, dependente): T
! Mtodo numrico: diferenas finitas
! Funo de interpolao: CDS (varivel primria T)
! As condies de contorno so aplicadas forando os
! coeficientes e fontes a satisfazer a C.C.
! Malha uniforme
! Solvers: Eliminao de Gauss, Gauss-Seidel e TDMA
! Preciso: dupla
! Linguagem FORTRAN 95
! Aplicativo usado: Fortran 4.0 Microsoft
! Tipo de projeto: Console
! Expresso genrica do sistema de equaes discretizado:
! aP(i)*T(i) = aw(i)*T(i-1) + ae(i)*T(i+1) + bP(i)
! onde i = 1, 2, ... N (nmero de ns)
! ARQUIVOS envolvidos no programa:

! programa20a.f90 = programa principal
! coeficientes.f90 = calcula coeficientes e fontes do sistema linear
! dados.f90 = l e lista os dados do programa
! resultados.f90 = resolve equaes e gera listagens dos resultados
! solvers_1D.f9 = Solvers Eliminao de Gauss, Gauss-Seidel e TDMA
! variaveis.f90 = define todas as variveis globais do programa
! programa20a.ent = arquivo de dados do programa
! "caso" = listagem dos resultados
! T.dat = arquivo de dados para fazer grfico
! comandos20a.gnu = arquivo de comandos para gerar grfico
! notepad.exe = aplicativo editor dos arquivos tipo texto
! Wgnuplot.exe = aplicativo gerador de grfico
! -----------------------------------------------

use dados
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)
write(aux,*) var(1)
dia = '('//trim(aux1)//'/'//trim(aux2)//'/'//aux3//')'
write(aux,*) var(5)
write(aux,*) var(6)
write(aux,*) var(7)
hora = trim(aux1)//':'//trim(aux2)//':'//aux3
call le_dados
head = trim(title)//" "//trim(dia)//"'"
open(10,file=caso)
comp = len(trim(adjustl(title)))
write(10,18) trim(adjustl(title)), dia, hora

18 format(/,'Ttulo = ', a<comp>, &
//,5x,'Dia = ',a12,5x,'Hora = ',a8)

! alocao de memria
allocate ( X(N), T(N) )
allocate ( aw(N), aP(N), ae(N), bP(N) )
do i = 1, N
X(i) = (i-1.0d0) / (N-1)
end do
call mostra_dados
call solucao_numerica
close (10)
note_caso = 'notepad '//caso

ver = system(note_caso) ! lista arquivo de resultados
! -----------------------------------------------
End
Figura 20.1 Arquivo de comandos para o aplicativo Wgnuplot do programa20a.f90.
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.
15) Executar o programa atravs 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 soluo 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.

solver = 3, e analisar os novos resultados. Notar a reduo significativa no tempo de CPU ao se usar
o mtodo TDMA em relao ao mtodo de Eliminao de Gauss.
solver = 3, e analisar os novos resultados.
20.2 EXERCCIOS

Exerccio 20.1
Executar novamente o programa20a.f90 usando os mesmos dados da Figura 20.2, exceto, matriz = 1 e
solver = 2. Por tentativa e erro, usar um valor para a varivel iteracao que seja suficiente para satisfazer
a tolerncia (Tol) estipulada na Figura 20.2. Comparar o tempo de CPU resultante neste caso, para o
mtodo de Gauss-Seidel, quele do mtodo TDMA (item 18) e do mtodo de Eliminao de Gauss (item
17).
Figura 20.4 Arquivo de resultados do programa20a.f90 para os dados da Fig. 20.2.
Exerccio 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 varivel iteracao que seja suficiente para satisfazer
a tolerncia (Tol) estipulada na Figura 20.2. Comparar o tempo de CPU resultante neste caso, para o
mtodo de Gauss-Seidel, quele do mtodo TDMA (item 19) e do mtodo de Eliminao de Gauss (item
16).

Procedimento: CRIAR E INSERIR PROGRAMA-FONTE NO PROJETO
Explicaes detalhadas esto na seo 1.7 do captulo 1.
Para iniciar a edio ou escrita de um programa-fonte em linguagem FORTRAN necessrio criar

e inserir um arquivo dentro do projeto. Isso feito atravs dos seguintes passos:
1) No menu do Fortran, executar: Insert, Files into Project
2) Na janela Insert Files into Project, executar o seguinte:
a) Na opo File Name, digitar o nome do programa-fonte a ser criado. Sempre deve-se usar f90
como extenso dos nomes dos arquivos do tipo programa-fonte. Ele indica que o programa est ou
ser escrito na linguagem FORTRAN 90 ou 95.
b) Clicar sobre o boto OK
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
5) Clicar duas vezes sobre o nome do programa-fonte que foi inserido
7) O programa-fonte inserido no projeto j est pronto para ser editado na subjanela do lado direito do
Fortran
Procedimento: Criar e inserir programa-fonte no projeto 1

Procedimento: CRIAR PROJETO DO TIPO CONSOLE APPLICATION
Explicaes detalhadas esto na seo 1.6 do captulo 1.
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 opo Project Workspace. Depois, clicar sobre o boto OK.
3) Na janela New Project Workspace, necessrio executar o que segue:
a) Entre os seis tipos de projetos apresentados na opo Type, clicar sobre Console Application no
caso deste tipo de projeto no estar selecionado (realado em azul).
b) Na opo Location estar indicado um diretrio (pasta) default, ou seja, um diretrio escolhido
pelo prprio Fortran em funo de sua configurao atual. possvel que no seja o diretrio
desejado. Neste caso, deve-se clicar sobre o boto Browse para indicar o diretrio onde se quer
criar o projeto. Ao se fazer isso, surgir a janela Choose Directory na qual deve-se executar:
Na opo Drives, escolher Z:\\SERVER1\Alunos2004_1
Na opo Directory name, clicar duas vezes sobre o nome do diretrio que idntico ao
user name usado para acessar a rede Windows do DEMEC/UFPR
Clicar sobre o boto OK.
c) Estar de volta a janela New Project Workspace. Clicar dentro do espao de edio da opo
Name. Escrever o nome do projeto. Deve-se perceber que o nome do projeto, digitado na opo
Name, aparece automaticamente na opo Location. Em seguida, deve-se clicar sobre o boto
Create. Aps isso, o Fortran criar um diretrio com o nome do projeto indicado, dentro do
diretrio j selecionado.
Procedimento: Criar projeto do tipo Console Application 1

Procedimento: FIM DE SESSO

Workspace
Procedimento: Fim de sesso 1

REFERNCIAS BIBLIOGRFICAS
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.
FORBELLONE, A. L. V.; EBERSPACHER, H. F. Lgica de Programao. 2a ed. So Paulo : Makron

Books, 2000.
HAHN, B. Fortran 90 for Scientists and Engineers. New York : Chapman & Hall, 1994.
MORAES, P. S. Curso Bsico de Lgica de Programao. Campinas, 2000.
RAMALHO, J. A. A. Introduo Informtica. So Paulo : Berkeley, 2000.
Referncias bibliogrficas 1

Fortran90 Index

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Fortran90 Index

Încărcat de

Drepturi de autor:

Formate disponibile

FORTRAN 90

OBJETIVOS DO CAPTULO ............................................................................................................................................. 7

1.1 USO DESTE TEXTO EM DISCIPLINAS .................................................................................................................... 7

1.2 BIBLIOGRAFIA ..................................................................................................................................................... 7

1.5 INICIALIZAO DO APLICATIVO FORTRAN POWERSTATION 4.0 ........................................................................ 9

1.6 CRIAO DE UM PROJETO DO TIPO CONSOLE APPLICATION .......................................................................... 11

1.7 CRIAO E INSERO DO PROGRAMA-FONTE DENTRO DO PROJETO ............................................................ 14

1.8 EDIO DO PROGRAMA-FONTE ....................................................................................................................... 17

1.9 COMPILAO E GERAO DO PROGRAMA-OBJETO ........................................................................................ 18

1.10 GERAO DO PROGRAMA-EXECUTVEL ........................................................................................................ 20

1.11 EXECUO DO PROGRAMA ............................................................................................................................ 21

1.12 FIM DA SESSO ............................................................................................................................................... 22

1.13 EXERCIOS ....................................................................................................................................................... 23

Captulo 2. VARIVEIS DO TIPO INTEIRO ........................................................................................................................ 24

OBJETIVOS DO CAPTULO ........................................................................................................................................... 24

2.1 programa02.f90, verso A ................................................................................................................................ 24

2.2 programa02.f90, verso B ................................................................................................................................ 26

2.3 programa02.f90, verso C ................................................................................................................................ 27

2.4 programa02.f90, verso D ................................................................................................................................ 28

2.5 programa02.f90, verso E................................................................................................................................. 29

2.6 programa03.f90, verso A ................................................................................................................................ 30

2.7 programa03.f90, verso B ................................................................................................................................ 33

2.8 FIM DA SESSO ................................................................................................................................................. 35

2.9 EXERCIOS ......................................................................................................................................................... 35

Captulo 3. VARIVEIS DO TIPO REAL ............................................................................................................................. 37

3.1 programa03c.f90 .............................................................................................................................................. 37

3.2 programa03d.f90 .............................................................................................................................................. 40

3.3 programa03e.f90 .............................................................................................................................................. 41

3.4 ESCALA DE PRIORIDADES ENTRE OS OPERADORES MATEMTICOS ................................................................ 43

3.5 programa03f.f90 ............................................................................................................................................... 45

3.6 EXERCCIOS ....................................................................................................................................................... 48

Captulo 4. VARIVEIS DO TIPO CARACTER .................................................................................................................... 50

OBJETIVOS DO CAPTULO ........................................................................................................................................... 50

4.1 programa4a.f90 ................................................................................................................................................ 50

4.2 programa4b.f90 ................................................................................................................................................ 53

4.3 programa4c.f90 ................................................................................................................................................ 54

4.4 programa4d.f90 ................................................................................................................................................ 56

4.5 EXERCCIO ......................................................................................................................................................... 54

Captulo 5. ARQUIVOS E FUNES MATEMTICAS INTRNSECAS ................................................................................. 55

OBJETIVOS DO CAPTULO ........................................................................................................................................... 55

5.1 programa5a.f90 ................................................................................................................................................ 55

5.2 programa5b.f90 ................................................................................................................................................ 57

5.3 programa5c.f90 ................................................................................................................................................ 60

5.4 programa5d.f90 ................................................................................................................................................ 62

5.5 EXERCCIOS ....................................................................................................................................................... 66

Captulo 6. FORMATOS DE EDIO ................................................................................................................................ 68

OBJETIVOS DO CAPTULO ........................................................................................................................................... 68

6.1 FORMATOS DE EDIO PARA VARIVEIS DO TIPO CARACTER: programa6a.f90............................................. 68

6.2 FORMATOS DE EDIO PARA VARIVEIS DO TIPO INTEIRO: programa6b.f90 ................................................ 73

6.3 FORMATOS DE EDIO PARA VARIVEIS DO TIPO REAL: programa6c.f90 ...................................................... 76

6.4 RESUMO DE REGRAS GERAIS DE EDIO DE PROGRAMAS EM FORTRAN ....................................................... 80

6.5 SEQNCIA OBRIGATRIA DE COMANDOS EM FORTRAN............................................................................... 81

6.6 EXERCCIOS ....................................................................................................................................................... 81

Captulo 7. DECISES E OPES ..................................................................................................................................... 83

7.1 programa7a.f90 ................................................................................................................................................ 83

7.2 programa7b.f90 ................................................................................................................................................ 86

7.3 programa7c.f90 ................................................................................................................................................ 89

7.4 EXERCCIOS ....................................................................................................................................................... 92

Captulo 8. CICLOS .......................................................................................................................................................... 94

OBJETIVOS DO CAPTULO ....................................................................................................................................... 94

8.1 programa8a.f90 ................................................................................................................................................ 94

8.2 programa8b.f90 ................................................................................................................................................ 95

8.3 programa8c.f90 ................................................................................................................................................ 99

8.4 EXERCCIOS ..................................................................................................................................................... 102