Fortran90 index

2
Sumário
Capítulo 1. INTRODUÇÃO ................................................................................................................................................. 7
OBJETIVOS DO CAPÍTULO ............................................................................................................................................. 7
1.1 USO DESTE TEXTO EM DISCIPLINAS .................................................................................................................... 7
1.2 BIBLIOGRAFIA ..................................................................................................................................................... 7
1.3 FORTRAN ............................................................................................................................................................. 8
1.4 CONVENÇÕES ...................................................................................................................................................... 8
1.5 INICIALIZAÇÃO DO APLICATIVO FORTRAN POWERSTATION 4.0 ........................................................................ 9
1.6 CRIAÇÃO DE UM PROJETO DO TIPO CONSOLE APPLICATION .......................................................................... 11
1.7 CRIAÇÃO E INSERÇÃO DO PROGRAMA-FONTE DENTRO DO PROJETO ............................................................ 14
1.8 EDIÇÃO DO PROGRAMA-FONTE ....................................................................................................................... 17
1.9 COMPILAÇÃO E GERAÇÃO DO PROGRAMA-OBJETO ........................................................................................ 18
1.10 GERAÇÃO DO PROGRAMA-EXECUTÁVEL ........................................................................................................ 20
1.11 EXECUÇÃO DO PROGRAMA ............................................................................................................................ 21
1.12 FIM DA SESSÃO ............................................................................................................................................... 22
1.13 EXERÍCIOS ....................................................................................................................................................... 23
Capítulo 2. VARIÁVEIS DO TIPO INTEIRO ........................................................................................................................ 24
OBJETIVOS DO CAPÍTULO ........................................................................................................................................... 24
2.1 programa02.f90, versão A ................................................................................................................................ 24
2.2 programa02.f90, versão B ................................................................................................................................ 26
2.3 programa02.f90, versão C ................................................................................................................................ 27
2.4 programa02.f90, versão D ................................................................................................................................ 28
2.5 programa02.f90, versão E ................................................................................................................................. 29
2.6 programa03.f90, versão A ................................................................................................................................ 30
2.7 programa03.f90, versão B ................................................................................................................................ 33
2.8 FIM DA SESSÃO ................................................................................................................................................. 35
2.9 EXERÍCIOS ......................................................................................................................................................... 35
Capítulo 3. VARIÁVEIS DO TIPO REAL ............................................................................................................................. 37

3
3.1 programa03c.f90 .............................................................................................................................................. 37
3.2 programa03d.f90 .............................................................................................................................................. 40
3.3 programa03e.f90 .............................................................................................................................................. 41
3.4 ESCALA DE PRIORIDADES ENTRE OS OPERADORES MATEMÁTICOS ................................................................ 43
3.5 programa03f.f90 ............................................................................................................................................... 45
3.6 EXERCÍCIOS ....................................................................................................................................................... 48
Capítulo 4. VARIÁVEIS 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 EXERCÍCIO ......................................................................................................................................................... 54
Capítulo 5. ARQUIVOS E FUNÇÕES MATEMÁTICAS INTRÍNSECAS ................................................................................. 55
5.1 programa5a.f90 ................................................................................................................................................ 55
5.2 programa5b.f90 ................................................................................................................................................ 57
5.3 programa5c.f90 ................................................................................................................................................ 60
5.4 programa5d.f90 ................................................................................................................................................ 62
5.5 EXERCÍCIOS ....................................................................................................................................................... 66
Capítulo 6. FORMATOS DE EDIÇÃO ................................................................................................................................ 68
6.1 FORMATOS DE EDIÇÃO PARA VARIÁVEIS DO TIPO CARACTER: programa6a.f90............................................. 68
6.2 FORMATOS DE EDIÇÃO PARA VARIÁVEIS DO TIPO INTEIRO: programa6b.f90 ................................................ 73
6.3 FORMATOS DE EDIÇÃO PARA VARIÁVEIS DO TIPO REAL: programa6c.f90 ...................................................... 76
6.4 RESUMO DE REGRAS GERAIS DE EDIÇÃO DE PROGRAMAS EM FORTRAN ....................................................... 80
6.5 SEQÜÊNCIA OBRIGATÓRIA DE COMANDOS EM FORTRAN............................................................................... 81
6.6 EXERCÍCIOS ....................................................................................................................................................... 81
Capítulo 7. DECISÕES E OPÇÕES ..................................................................................................................................... 83

4
7.1 programa7a.f90 ................................................................................................................................................ 83
7.2 programa7b.f90 ................................................................................................................................................ 86
7.3 programa7c.f90 ................................................................................................................................................ 89
7.4 EXERCÍCIOS ....................................................................................................................................................... 92
Capítulo 8. CICLOS .......................................................................................................................................................... 94
OBJETIVOS DO CAPÍTULO ....................................................................................................................................... 94
8.1 programa8a.f90 ................................................................................................................................................ 94
8.2 programa8b.f90 ................................................................................................................................................ 95
8.3 programa8c.f90 ................................................................................................................................................ 99
8.4 EXERCÍCIOS ..................................................................................................................................................... 102
Capítulo 9. CONJUNTOS ................................................................................................................................................ 104
OBJETIVOS DO CAPÍTULO ......................................................................................................................................... 104
9.1 programa9a.f90 .............................................................................................................................................. 104
9.2 programa9b.f90 .............................................................................................................................................. 108
9.3 programa9c.f90 .............................................................................................................................................. 110
9.4 programa9d.f90 .............................................................................................................................................. 113
9.5 EXERCÍCIOS ..................................................................................................................................................... 115
Capítulo 10. MATRIZES ................................................................................................................................................. 117
10.1 programa10a.f90 .......................................................................................................................................... 117
10.2 programa10b.f90 .......................................................................................................................................... 122
10.3 EXERCÍCIOS ................................................................................................................................................... 128
Capítulo 11. GRÁFICOS COM WGNUPLOT .................................................................................................................... 130
11.1 INSERÇÃO DO APLICATIVO WGNUPLOT NUM PROJETO .............................................................................. 130
11.2 UTILIZAÇÃO BÁSICA DO WGNUPLOT ............................................................................................................ 130
11.3 UTILIZAÇÃO DO WGNUPLOT PARA FAZER GRÁFICO DE UM ARQUIVO DE DADOS ...................................... 133
11.4 UTILIZAÇÃO DO WGNUPLOT COM ARQUIVO DE COMANDOS ..................................................................... 136
11.5 programa11.f90 ............................................................................................................................................ 137

5
11.6 EXERCÍCIOS ................................................................................................................................................... 140
Capítulo 12. SUB-ROTINAS ............................................................................................................................................ 141
12.1 programa12a ................................................................................................................................................ 141
12.2 programa12b ................................................................................................................................................ 145
12.3 programa12c ................................................................................................................................................. 148
12.4 programa12d ................................................................................................................................................ 150
12.5 EXERCÍCIO ..................................................................................................................................................... 153
Capítulo 13. VARIÁVEIS DO TIPO REAL DUPLA ............................................................................................................. 154
13.1 programa13a.f90 .......................................................................................................................................... 154
13.3 programa13c.f90 .......................................................................................................................................... 158
13.4 programa13d.f90 .......................................................................................................................................... 160
13.5 EXERCÍCIOS ................................................................................................................................................... 163
Capítulo 14. ARQUIVOS DE SAÍDA, 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 EXERCÍCIOS ................................................................................................................................................... 176
Capítulo 15. INICIALIZAÇÃO, TEMPO DE CPU E DOS .................................................................................................... 178
15.1 programa15a.f90 .......................................................................................................................................... 178
15.2 programa15b.f90 .......................................................................................................................................... 180
15.3 programa15c.f90 .......................................................................................................................................... 185
15.4 EXERCÍCIOS ................................................................................................................................................... 189
Capítulo 16. MEMÓRIA E SUB-ROTINAS 2 .................................................................................................................... 191

6
16.1 programa16a.f90 .......................................................................................................................................... 191
16.2 programa16b.f90 .......................................................................................................................................... 197
16.3 programa16c.f90 .......................................................................................................................................... 199
16.4 EXERCÍCIOS ................................................................................................................................................... 204
Capítulo 17. MÓDULOS ................................................................................................................................................. 206
OBJETIVOS DO CAPÍTULO ..................................................................................................................................... 206
17.1 programa17a.f90 .......................................................................................................................................... 206
17.2 programa17b.f90 .......................................................................................................................................... 209
17.3 programa17c.f90 .......................................................................................................................................... 212
17.4 EXERCÍCIOS ................................................................................................................................................... 213
Capítulo 18. SOLUÇÃO DE SÉRIES E RAÍZES DE EQUAÇÕES .......................................................................................... 212
18.1 programa18a.f90 .......................................................................................................................................... 212
18.2 programa18b.f90 .......................................................................................................................................... 218
18.3 EXERCÍCIOS ................................................................................................................................................... 223
Capítulo 19. DERIVADAS E INTEGRAIS NUMÉRICAS ..................................................................................................... 226
19.2 programa19b.f90 .......................................................................................................................................... 234
19.3 EXERCÍCIOS ................................................................................................................................................... 241
Capítulo 20. SOLUÇÃO DE SISTEMAS DE EQUAÇÕES.................................................................................................... 243
20.1 programa20a.f90 .......................................................................................................................................... 243
20.2 EXERCÍCIOS ....................................................................................................................................................... 261
Procedimento: CRIAR PROJETO DO TIPO CONSOLE APPLICATION ............................................................................... 264
Procedimento: FIM DE SESSÃO .................................................................................................................................... 265
REFERÊNCIAS BIBLIOGRÁFICAS ..................................................................................................................................... 266

7
Capítulo 1. INTRODUÇÃO
OBJETIVOS DO CAPÍTULO
• Conceitos de: linguagem de programação, FORTRAN, projeto, programa-fonte, programa-objeto, programa-executável, compilação, comando
• Procedimentos básicos para programar em linguagem FORTRAN
• Comandos do FORTRAN: WRITE e END
1.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 básicos de matemática e física. Os capítulos 1 a 13 deste texto são recomendados para disciplinas introdutórias de programação em cursos de engenharia. Já os capítulos 14 a 20 podem ser usados em cursos avançados de programação em nível de graduação.
Cada capítulo foi estruturado para ser lecionado em aulas com duração de duas horas. Uma disciplina de 30 horas vem sendo ministrada no primeiro período semestral do curso de graduação em engenharia mecânica da Universidade Federal do Paraná. Esta disciplina envolve os capítulos 1 a 13 mais duas provas. Outra disciplina, envolvendo os capítulos 1 a 20, com 45 horas, está prevista para ser lecionada em nível de pós-graduação.
1.2 BIBLIOGRAFIA
Não é objetivo deste texto entrar em detalhes sobre hardware e software de computadores. Aos interessados nestes aspectos recomenda-se o livro de Ramalho (2000), que é adotado neste texto como referência para termos técnicos de informática em português. Dois textos recomendados sobre algoritmos são o livro de Forbellone e Eberspacher (2000) e a apostila de Moraes (2000). O material apresentado aqui é baseado no livro de Adams et al. (1997), que se constitui num manual completo sobre a linguagem FORTRAN 95, padronizada pelas organizações ISO (International Standadrs Organization) e ANSI (American National Standards Institute).

8
1.3 FORTRAN
Existe uma infinidade de linguagens de programação, por exemplo, Assembly, Cobol, Visual Basic, Pascal, Java, C++ etc (Ramalho, 2000, p. 114 e 124-30). Elas são usadas para criar os programas, também denominados de softwares ou aplicativos, que são empregados nos computadores. A utilidade das linguagens de programação pode ser percebida ao se lembrar para que são usados, por exemplo: os sistemas operacionais Windows, Unix e Linux; os aplicativos Word, Excel, PowerPoint, FrontPage, CorelDraw, Origin e Acrobat; os navegadores da internet Netscape e Explorer; e os programas dos caixas automáticos dos bancos.
A linguagem FORTRAN, contração de FORmula TRANslation (Tradução de Fórmulas), ainda é a principal linguagem de programação usada em engenharia e aplicações científicas (Adams, 2000, p. 1). Foi criada em 1954. Sua primeira versão comercial surgiu em 1957. As versões do FORTRAN padronizadas pela ANSI e ISO são:
1) Ano 1966 = FORTRAN 66
1.4 CONVENÇÕES
Para melhor entendimento deste texto, as seguintes convenções são adotadas:
1) São mostrados na cor azul links para endereços 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 são mostrados em negrito. A vírgula é usada para separar uma seqüência de comandos.
3) São apresentados na cor vermelha: os programas, seus dados (entradas) e seus resultados (saídas).
4) Qualquer referência ao sistema operacional Windows NT 4.0 é abreviado para Windows.
5) Qualquer referência ao aplicativo Fortran PowerStation 4.0, da Microsoft, é abreviado para Fortran.
6) Qualquer referência à linguagem FORTRAN é abreviado para FORTRAN, tudo em maiúsculo para distinguir do aplicativo Fortran PowerStation 4.0.
7) Devido à grande quantidade de termos em inglês, não é feito qualquer distinção para palavras em português.
8) Comandos, isto é, palavras-chave da linguagem FORTRAN são apresentados em letras maiúsculas.

9
1.5 INICIALIZAÇÃO DO APLICATIVO FORTRAN POWERSTATION 4.0
Para seguir este texto, não é necessário nenhum conhecimento anterior sobre linguagem de programação. É necessário apenas ter conhecimentos básicos sobre o sistema operacional Windows NT
4.0 ou versões mais recentes. Todos os programas em FORTRAN apresentados neste texto foram editados e compilados com o aplicativo Fortran PowerStation 4.0, da Microsoft. Além de seus manuais, este aplicativo contém o livro de Hahn (1994) sobre FORTRAN 90 e o item Reference onde são descritos todos os comandos do FORTRAN, incluindo exemplos.
Conforme é mostrado na Figura 1.1, para iniciar o uso deste aplicativo, deve-se executar no Windows: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio. Para facilitar a edição dos programas, recomenda-se maximizar a janela principal do Fortran, clicando sobre o ícone central que fica no canto superior direito. Fazendo isso, o aspecto do Fortran deverá ser semelhante
àquele mostrado na Figura 1.2.
Figura 1.1 Inicialização do aplicativo Fortran PowerStation 4.0. Na janela principal do Fortran, mostrada na Figura 1.2, pode-se perceber:

1
Figura 1.2 Janela principal do aplicativo Fortran PowerStation 4.0.
1) Na barra em azul, o ícone do Fortran e o título da janela principal: Microsoft Developer Studio.
2) Abaixo da barra em azul, o menu do Fortran, ou seja, as opções existentes para usar este aplicativo, que são: File, Edit, View, Insert, Build, Tools, Window e Help.
3) A janela principal do Fortran é dividida em três partes ou subjanelas. Se não estiver aparecendo a subjanela inferior, mostrada na Figura 1.2, deve-se executar: View, Output.
4) Na subjanela do lado esquerdo, tem-se o diretório principal dos manuais do Fortran, destacando-se: Reference, que é uma lista de comandos do FORTRAN 90, incluindo explicações e exemplos de uso; e Fortran 90 for Scientists and Engineers, que é um livro sobre a linguagem FORTRAN 90. Esta subjanela também é usada para mostrar os nomes dos programas editados na linguagem FORTRAN. Quando um programa estiver sendo editado, para acessar os manuais, deve-se clicar sobre a opção ? InfoView, mostrada na Figura 1.2, que fica na parte inferior da subjanela do lado esquerdo. E para voltar ao programa que está sendo editado, basta clicar sobre a opção FileView.
5) Na subjanela inferior são apresentadas informações sobre erros de programação e compilação.
Detalhes serão vistos no capítulo 2.
6) A subjanela do lado direito, a maior das três, é usada para: apresentar o conteúdo dos manuais e para a edição de programas em FORTRAN.

1
1.6 CRIAÇÃO DE UM PROJETO DO TIPO CONSOLE APPLICATION
O Fortran organiza todos os arquivos de um programa numa entidade chamada projeto. Em termos práticos, a criação de um projeto resulta na criação de uma pasta ou diretório dentro do Windows. Existem diversos tipos de projetos que podem ser criados com o Fortran. A escolha do tipo depende da finalidade do programa e dos recursos do Windows que se deseja empregar. No caso deste texto, em sua parte básica, que compreende os capítulos 1 a 13, são empregados apenas projetos do tipo Console Application. E na parte avançada, que corresponde aos capítulos 14 a 20, são usados projetos do tipo QuickWin Application, que permite utilizar diversos recursos do Windows.
Para criar um projeto do tipo Console Application, devem ser executados os seguintes passos:
1) No menu do Fortran, conforme é mostrado na Figura 1.3: File, New.
Figura 1.3 Início da criação de um projeto no Fortran.
2) Na janela New, mostrada na Figura 1.4, clicar sobre a opção Project Workspace. Depois, clicar sobre o botão OK.
3) Na janela New Project Workspace, mostrada na Figura 1.5, é necessário executar o que segue:

1
Figura 1.4 Segundo passo na criação de um projeto no Fortran.
Figura 1.5 Janela para definição do tipo, diretório e nome do projeto.
a) Entre os seis tipos de projetos apresentados na opção Type, clicar sobre Console Application no caso deste tipo de projeto não estar selecionado (realçado em azul).
b) Na opção Location estará indicado um diretório (pasta) default, ou seja, um diretório escolhido pelo próprio Fortran em função de sua configuração atual. É possível que não seja o diretório desejado. Neste caso, deve-se clicar sobre o botão Browse para indicar o diretório onde se quer criar o projeto. Ao se fazer isso, surgirá a janela Choose Directory mostrada na Figura 1.6, na qual deve-se executar:
• Na opção Drives, clicando sobre o triângulo invertido, escolher C:
• Na opção Directory name, digitar C:MSDEVProjects, conforme é mostrado na Figura 1.7.
• Clicar sobre o botão OK.
c) Estará de volta a janela New Project Workspace, mostrada na Figura 1.5. Clicar dentro do espaço de edição da opção Name. Escrever o nome do projeto, por exemplo, programa01. Depois disso, a janela New Project Workspace deverá ficar conforme a Figura 1.8. Deve-se perceber que o nome do projeto, digitado na opção Name, aparece automaticamente na opção Location. Em

1
seguida, deve-se clicar sobre o botão Create. Após isso, o Fortran criará um diretório com o nome
do projeto indicado, dentro do diretório já selecionado, conforme é mostrado na Figura 1.9.
Figura 1.6 Definição do drive do projeto.
Figura 1.7 Definição do diretório para criação do projeto.
Figura 1.8 Tipo, nome e diretório do projeto já definidos.

Capítulo 1. Introdução 14
Figura 1.9 Fortran com o nome do diretório criado para o projeto especificado.
1.7 CRIAÇÃO E INSERÇÃO DO PROGRAMA-FONTE DENTRO DO PROJETO
O processo de edição ou criação de um programa é semelhante à redação de uma carta com o aplicativo Word, que é um editor de textos. São necessários 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 edição, digitação e implementação serão usadas como sinônimos. Para iniciar a edição ou escrita de um programa-fonte em linguagem FORTRAN é necessário criar e inserir um arquivo dentro do projeto. Isso é feito através 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 opção 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 extensão 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 botão OK
Figura 1.10 Início da criação do programa-fonte.
Figura 1.11 Janela para definição do nome do programa-fonte a inserir no projeto.
3) Na janela Microsoft Developer Studio, mostrada na Figura 1.13, clicar sobre o botão Yes
4) Na subjanela do lado esquerdo do Fortran, clicar sobre o sinal + ao lado do nome do projeto; deverá aparecer o nome do programa-fonte que foi inserido no projeto; no caso, programa01.f90
5) Clicar rapidamente duas vezes sobre o nome do programa-fonte que foi inserido

6) Na janela Microsoft Developer Studio, mostrada na Figura 1.14, clicar sobre o botão Yes
7) O programa-fonte inserido no projeto já está pronto para ser editado na subjanela do lado direito do
Fortran, conforme mostrado na Figura 1.15.
Figura 1.12 Nome do programa-fonte já definido.
Figura 1.13.
Figura 1.14.

Figura 1.15 Fortran pronto para edição do programa-fonte.
1.8 EDIÇÃO DO PROGRAMA-FONTE
Após a criação e inserção do programa-fonte dentro do projeto, o Fortran está pronto para ser usado na edição do programa-fonte, conforme mostrado na Figura 1.15. Um exemplo de edição de programa-fonte é apresentado a seguir.
1) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto mostrado abaixo em vermelho (para aparecerem as aspas, deve-se clicar sobre a tecla delas e, em seguida, clicar sobre a tecla de espaço em branco).
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 diretório e o nome do programa-fonte que foi gravado ou salvo, como mostrado na Figura 1.16.
3) Comentários sobre este programa:

a) Dentro do editor de textos do Fortran, os comandos da linguagem FORTRAN são mostrados na cor azul, conforme pode ser visto na Figura 1.16. E o que é criado ou definido pelo programador é mostrado na cor preta. Comandos são palavras-chave que têm uma função específica e devem ser usados exatamente de acordo com suas normas.
b) Existem dezenas de comandos na linguagem FORTRAN. No caso do primeiro programa-fonte, mostrado na Figura 1.16, são usados apenas dois comandos: WRITE e END.
c) Como será visto após a execução deste programa, ele simplesmente irá mostrar numa janela duas linhas de texto: na primeira, Meu primeiro programa em Fortran; e, na segunda, Ano 2004. Isso é conseguido com o comando WRITE. Qualquer texto colocado entre aspas após o comando WRITE(*,*) é escrito numa janela.
d) O comando END é necessário para indicar o fim do programa.
Figura 1.16 Programa-fonte escrito na linguagem FORTRAN.
1.9 COMPILAÇÃO E GERAÇÃO DO PROGRAMA-OBJETO
Após concluir a edição de um programa-fonte, ele deve ser compilado. O processo de compilação traduz o programa-fonte (que é um arquivo do tipo texto, isto é, que as pessoas conseguem ler naturalmente, como o programa01.f90) no chamado programa-objeto, que é um arquivo do tipo binário

(escrito na linguagem dos computadores, usando apenas os algarismos zero-0 e um-1). Uma linguagem de programação de alto nível (Ramalho, 2000) como o FORTRAN se constitui numa forma “amigável” ou relativamente fácil de se escrever programas. O aplicativo Fortran PowerStation 4.0, além do editor de programas, também tem junto um compilador de programas. Para compilar um programa-fonte que está aberto no editor de textos do Fortran, deve-se executar o seguinte no menu do Fortran: Build, Compile
Após a compilação, conforme é mostrado na Figura 1.17, aparecerão três linhas com mensagens na subjanela da parte inferior do Fortran:
1) A primeira informa que o Fortran está compilando (Compiling) o programa-fonte.
2) A segunda informa o nome e o diretório do programa-fonte que está sendo compilado.
3) Finalmente, a terceira informa o nome do programa-objeto (no caso, programa01.obj) que foi gerado e o número de erros (errors) e de avisos (warnings) relativos ao programa-fonte compilado. Se houver algum erro, o programa-objeto não é gerado. Avisos não impedem a geração do programa-objeto. O nome do programa-objeto é igual ao nome do programa-fonte mas com extensão obj
Figura 1.17 Compilação do programa-fonte.
A compilação cria automaticamente um subdiretório chamado Debug dentro do diretório do projeto. Dentro deste subdiretório é 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 diretório do projeto, que deve estar dentro do diretório C:MsdevProjects
1.10 GERAÇÃO DO PROGRAMA-EXECUTÁVEL
Após o processo de compilação, é necessário gerar o programa-executável, que é um arquivo possível 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-executável resulta da união do programa-objeto, que foi gerado na compilação do programa-fonte, com outros programas-objeto da própria linguagem FORTRAN, que contêm a tradução dos comandos do FORTRAN, como o WRITE e END usados no primeiro programa- fonte (Figura 1.17).
Para gerar o programa-executável, deve-se fazer o seguinte no menu do Fortran: Build, Build. Em seguida, conforme é mostrado na Figura 1.18, aparecerão duas linhas com mensagens na subjanela da
parte inferior do Fortran:
Figura 1.18 Geração do programa-executável.

1) A primeira informa que o Fortran está gerando o programa-executável, processo chamado de lincagem (linking).
2) A segunda informa o nome do programa-executável (no caso, programa01.exe) que foi gerado e o número de erros (errors) e de avisos (warnings) relacionados a ele. O nome do programa-executável é igual ao nome do projeto mas com extensão exe
O programa-executável é gravado automaticamente dentro do subdiretório Debug, que fica dentro do diretório do projeto, além de outros arquivos auxiliares. Isso pode ser visto com o aplicativo Windows NT Explorer, como mostrado na Figura 1.19. Note nesta figura que no Windows NT Explorer a extensão
ou Type do programa-executável aparece como Application.
Figura 1.19 Diretório do projeto programa01 e seu subdiretório Debug.
1.11 EXECUÇÃO DO PROGRAMA
Após gerar o programa-executável, 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 seção 1.6 foi criado um projeto do tipo Console Application.

2) No título desta janela, com fundo em azul, aparece o nome do programa que está sendo executado e o diretório no qual ele se encontra, no caso C:MSDEVProjectsprograma01Debugprograma01.exe
3) Dentro desta janela, com fundo em preto, aparece o resultado da execução do programa. No caso, as frases Meu primeiro programa em Fortran e Ano 2004. A ordem das duas frases é a mesma em que elas foram colocadas no programa-fonte. Isso ocorre, porque o programa é executado do topo para baixo, linha por linha do programa-fonte.
4) Além disso, também aparece a frase Press any key to continue. Como diz este aviso, basta clicar em
qualquer tecla para continuar. Ao fazer isso, a execução do programa é encerrada.
Figura 1.20 Resultado da execução do programa01.
1.12 FIM DA SESSÃO
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 botão 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 opção Close all programs and log on as a different user?. Clicar sobre o botão Yes

1.13 EXERÍCIOS
Exercício 1.1
1) Editar um programa-fonte em FORTRAN para escrever a data atual.
2) Compilar o programa-fonte
3) Gerar o programa-executável
4) Executar o programa
Exercício 1.2
1) Repetir o exercício 1.1 para escrever em linhas diferentes cada um dos seguintes itens: nome, e-mail, endereço e telefone de uma pessoa.

Capítulo 2. Variáveis do tipo inteiro 24
Capítulo 2. VARIÁVEIS DO TIPO INTEIRO
• Conceitos de: variáveis do tipo inteiro, atribuição, avisos e erros de compilação, erros de execução, comentários dentro do programa-fonte
• Operadores matemáticos básicos
• Comandos do FORTRAN: INTEGER e READ
2.1 programa02.f90, versão A
Para inicializar as atividades deste capítulo, deve-se executar:
1) No Windows, seguindo o procedimento apresentado na seção 1.5 do capítulo 1: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
2) No Fortran, seguindo o procedimento apresentado na seção 1.6 do capítulo 1, criar um projeto do tipo
Console Application com o nome programa02 no diretório Z:SERVER1Alunos2004_1login, onde login deve ser substituído pelo user name do usuário, isto é, a conta particular na rede Windows do DEMEC/UFPR.
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto o programa-fonte programa02.f90
4) Conforme é mostrado na Figura 2.1, dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto mostrado abaixo em vermelho.
INTEGER A WRITE(*,*) "A" WRITE(*,*) A END
5) Comentários sobre o programa:
a) No capítulo 1 foram usados os comandos WRITE e END da linguagem FORTRAN. No programa02.f90, há um novo comando: INTEGER. Ele é usado para definir variáveis do tipo inteiro, isto é, variáveis que podem guardar ou armazenar na memória do computador números inteiros, positivos ou negativos, como 2, 5, 0, 54367 ou –3.
b) A linha INTEGER A define a variável A como sendo do tipo inteiro. Este comando reserva um espaço na memória do computador, utilizando o nome ou rótulo A para armazenar um valor

inteiro.
c) A linha WRITE(*,*) "A" escreve o comentário que está entre aspas; no caso a letra A.
d) A linha WRITE(*,*) A escreve o valor da variável A que está armazenado na memória 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 variável A
não foi definido.
7) Gerar o programa-executável fazendo Build, Build.
Figura 2.1 Resultado da compilação do programa02.f90, versão A.
8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.2, dentro da qual tem-se:
a) Na primeira linha, a letra A, resultado do comando WRITE(*,*) "A" do programa.
b) Na segunda linha, o valor zero, resultado do comando WRITE(*,*) A do programa. Isso ocorre porque não foi definido um valor para a variável A, conforme o próprio Fortran informou durante a compilação do programa. Portanto, sempre é necessário definir o valor de cada variável do programa, caso contrário, por default, assume-se valor nulo.
c) E na terceira linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
9) Deve-se perceber a diferença que existe entre os comandos WRITE(*,*) "A" e WRITE(*,*) A do programa. No primeiro, A é um comentário. No segundo, A é uma variável utilizada para armazenar um valor inteiro na memória do computador.

Figura 2.2 Resultado da execução do programa02.f90, versão A.
2.2 programa02.f90, versão B
1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho.
INTEGER A A = 3
WRITE(*,*) "A" WRITE(*,*) A END
2) Comentários sobre o programa: a única diferença entre a versão anterior (A) e a atual (B) do programa02.f90 é a inclusão da segunda linha, ou seja, A = 3. O sinal de igualdade dentro de um programa escrito em linguagem FORTRAN é utilizado para atribuir o valor que está do lado direito à variável do lado esquerdo. Portanto, neste caso, o valor 3 é atribuído à variável A. Em outras palavras, o valor 3 é armazenado num espaço da memória do computador que é identificado pelo nome ou rótulo A, o nome da variável. Este valor utilizado (3) é apenas um exemplo; ele pode ser qualquer número inteiro.
3) Nesta versão do programa, ao se executar Build, Compile, não haverá aviso (warning) porque, neste caso, o valor da variável A está definido.
a) Na primeira linha, a letra A, resultado do comando WRITE(*,*) "A" do programa.
b) Na segunda linha, o valor 3, resultado do comando WRITE(*,*) A do programa e do comando anterior, A = 3.
c) E na terceira linha, a frase Press any key to continue.
6) Deve-se perceber que o programa é executado, linha por linha, da primeira (INTEGER A) até a última
(END).
7) Um exemplo de erro de compilação é apresentado na Figura 2.4. Ele ocorre devido à eliminação do segundo asterisco da terceira linha do programa. Erros de compilação ocorrem quando os comandos

do FORTRAN são utilizados de forma incorreta. Na subjanela inferior do Fortran, geralmente haverá um comentário indicando cada erro (error). Logo após o nome do programa-fonte compilado, entre parênteses, é indicado o número da linha do programa-fonte aonde deve estar o erro. No exemplo da Figura 2.4, o compilador do Fortran mostra o seguinte comentário: C:marchiprograma02programa02b.f90(3): error FOR3852: syntax error detected between , and ). Portanto, este comentário 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 vírgula e o sinal de fechamento de parênteses.
8) As linhas do programa-fonte são 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 são indicados a
linha (Ln) e a coluna (Col) aonde o cursor se encontra dentro do programa-fonte.
Figura 2.3 Resultado da execução do programa02.f90, versão B.
Figura 2.4 Exemplo de erro de compilação.
2.3 programa02.f90, versão C
INTEGER A A = 3
WRITE(*,*) "Valor de A = ", A

END
2) Comentários sobre o programa: a diferença básica entre a versão anterior (B) e a atual (C) do programa02.f90 é a junção dos dois comandos WRITE num só, na terceira linha do programa, isto é, WRITE(*,*) "Valor de A = ", A. Esta forma do comando WRITE é usada quando se quer escrever na mesma linha diversos elementos. No caso, são apenas dois elementos, ou seja, o comentário Valor de A = e a variável A. Os elementos devem ser separados por vírgula.
3) Executar Build, Compile para compilar o programa.
a) Na primeira linha, como resultado do comando WRITE(*,*) "Valor de A = ", A do programa, o comentário Valor de A = e, na mesma linha, o valor da variável A, cujo valor atribuído dentro do programa foi 3.
b) E na segunda linha, a frase Press any key to continue.
Figura 2.5 Resultado da execução do programa02.f90, versão C.
2.4 programa02.f90, versão D
INTEGER A A = 4
A = 3
WRITE(*,*) "Valor de A = ", A END
2) Comentários sobre o programa: a única diferença entre a versão anterior (C) e a atual (D) do programa02.f90 é a inclusão da linha A = 4, que atribui o valor 4 à variável A.

5) Ao se executar o programa, através 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 atribuído o valor 4 à variável A na segunda linha do programa, na linha seguinte atribui-se o valor 3 à mesma variável, e, na quarta linha do programa, escreve-se o valor de A. O valor escrito é 3 porque é o último valor que foi armazenado na memória do computador. A denominação variável é usada justamente porque seu valor pode ser alterado ao longo da execução do programa.
2.5 programa02.f90, versão 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 à variável A WRITE(*,*) "Valor de A = ", A
END
2) Comentários sobre o programa: em cada linha do programa-fonte, tudo que estiver à direita do símbolo ! (exclamação) não é executado pelo programa. São apenas comentários usados para esclarecer o que faz cada parte do programa. Isso é chamado de documentação interna. Dentro do editor do Fortran, todos os comentários ficam na cor verde, como é mostrado na Figura 2.6. Um comentário pode envolver uma linha inteira do programa, como na primeira da versão E, ou apenas uma parte, como na quarta linha do programa. Linhas em branco dentro do programa-fonte também não são executadas. Elas equivalem a um comentário em branco. Um exemplo é a terceira linha do programa02.f90, versão E, na Figura 2.6.
5) Ao se executar o programa, através de Build, Execute, o resultado é o mesmo mostrado na Figura
2.5. Isso ocorre porque as diferenças entre a versão C e a atual (E) do programa02.f90 são apenas os comentários e uma linha em branco, que não são executados pelo programa.
6) Para maior clareza e facilidade de compreensão do programa-fonte, recomenda-se que dentro dele sejam usados comentários e linhas em branco.

Figura 2.6 Programa02.f90, versão E.
2.6 programa03.f90, versão A
Para inicializar as atividades com o próximo programa, deve-se executar:
1) No Fortran, para fechar o projeto atual: File, Close Workspace
3) No Fortran, seguindo o procedimento apresentado na seção 1.6 do capítulo 1, criar um projeto do tipo Console Application com o nome programa03 no diretório Z:SERVER1Alunos2004_1login, onde login deve ser substituído pelo user name do usuário, isto é, a conta particular na rede Windows do DEMEC/UFPR.
4) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 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 D
=
=
A + B -
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 variáveis A, B, C, D, E, F e G como sendo do tipo inteiro. Este comando reserva espaço na memória do computador para diversas variáveis com apenas um comando INTEGER. Entretanto, as variáveis devem estar separadas por vírgula.
b) As linhas A = -6 e B = 2 atribuem os valores inteiros −6 e 2 às variáveis A e B. Estes valores são apenas exemplos; eles podem ser quaisquer números inteiros.
c) As variáveis C, D, E, F e G são calculadas em função dos valores das variáveis A e B, usando os cinco operadores matemáticos básicos definidos na Tabela 2.1, conforme explicado a seguir.
Tabela 2.1 Operadores matemáticos básicos em FORTRAN.
Símbolo do operador matemático em FORTRAN
Nome do símbolo
Operação matemática correspondente
+
Sinal mais
Adição
−
Sinal menos
Subtração
*
Asterisco
Multiplicação
/
Barra
Divisão
**
Duplo asterisco
Potenciação
d) A linha C = A + B adiciona os valores das variáveis A e B e atribui o resultado à variável C.
e) A linha D = B - A subtrai o valor da variável A do valor da variável B e atribui o resultado à variável D.
f) A linha E = A * B multiplica os valores das variáveis A e B e atribui o resultado à variável E.
g) A linha F = A / B divide o valor da variável A pelo valor da variável B e atribui o resultado à variável F.

h) A linha G = A ** B eleva o valor da variável A ao valor da variável B e atribui o resultado à variável G.
9) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.7, dentro da qual tem-se: os valores das variáveis A e B; e os valores resultantes das cinco operações matemáticas básicas da Tabela 2.1 efetuadas com as variáveis A e B. Analisar cada resultado, comparando-o com o valor esperado obtido de um cálculo mental.
10)Dentro do programa-fonte, fazer A = 1 e B = 2. Compilar e gerar o executável do programa com esta alteração. 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 cálculo mental. O resultado da divisão pode parecer incorreto mas não é. Isso se deve ao seguinte: o valor que resulta de um cálculo envolvendo dois números inteiros também é um número inteiro, que corresponde à parte inteira do número real equivalente ao cálculo realizado. Portanto, o resultado de 1 dividido por 2 resulta em 0,5, que é um número real. Mas como o cálculo envolve dois números inteiros, a parte inteira do número real 0,5 é 0, que é o resultado da divisão mostrado na Figura 2.8. Este tema será
explorado com mais detalhes no Capítulo 3.
Figura 2.7 Resultado da execução do programa03.f90, versão A, com A = −6 e B = 2.
Figura 2.8 Resultado da execução do programa03.f90, versão A, com A = 1 e B = 2.

11)Atribuir valores às variáveis dentro do próprio programa-fonte não é recomendável. Pois, para alterar os valores, é necessário ter o programa-fonte, além de recompilá-lo e gerar o programa-executável a cada vez. O procedimento mais indicado é utilizar o comando READ, apresentado na próxima seção.
2.7 programa03.f90, versão B
1) Dentro do Fortran, alterar o programa03.f90, versão A, para que fique exatamente igual ao texto mostrado abaixo em vermelho, incluindo as linhas em branco.
INTEGER A, B, C, D, E, F, G 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 diferença entre a versão anterior (A) e a atual (B) do programa03.f90 está no ínicio do programa. É a inclusão de 4 linhas novas no lugar de se atribuir valores às variáveis A e B.
b) Até aqui, os comandos da linguagem FORTRAN que foram usados são: WRITE, END e INTEGER. Na versão B do programa03.f90, há um novo comando: READ. Ele é usado para atribuir (fornecer) valores às variáveis durante a execução 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 comentário que está entre aspas.
d) A linha READ(*,*) A lê um valor digitado dentro da janela DOS, aberta durante a execução do programa, e o atribui à variável A.
5) Ao se executar o programa, através de Build, Execute, surge uma janela do tipo DOS dentro da qual tem-se:
a) Na primeira linha, o comentário Entre com o valor de A, resultado do comando WRITE(*,*) "Entre com o valor de A" do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor −6 para a variável A e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*) "Entre com o valor de B" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B, resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é necessário digitar o valor 2 para a variável B e, em seguida, clicar na tecla enter.
e) Em seguida, são apresentados os mesmos resultados da versão A do programa03.f90, conforme a
Figura 2.9.
Figura 2.9 Resultado da execução do programa03.f90, versão 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 cálculo mental.
7) Executar novamente o programa, com A = 6 e B = 0. Nenhum resultado é apresentado porque o programa não consegue dividir 6 por 0. Isso gera um erro que interrompe a execução normal do programa. Ao se implementar um programa, deve-se prepará-lo para que seja evitado qualquer

divisão por zero. Isso pode ser feito através de comentários que informem ao usuário do programa, na janela da execução do programa ou no manual do programa, por exemplo, quais as variáveis que não podem ter valor nulo. Outra forma mais efetiva de evitar divisão por zero será vista em capítulo
futuro.
2.8 FIM DA SESSÃO
Workspace
2.9 EXERÍCIOS
Exercício 2.1
Executar novamente o programa03.f90, versão B, com A = 2 e B = −1. Em seguida, analisar cada resultado, comparando-o com o valor esperado obtido de um cálculo mental, especialmente o caso da potenciação. No Fortran, para abrir um projeto já existente, como o programa03, basta executar File, Open Workspace. Em seguida, indicar o diretório do projeto e selecionar o arquivo que tem o nome do projeto e extensão mdp, no caso programa03.mdp
Exercício 2.2
Executar novamente o programa03.f90, versão B, usando números reais, isto é, A = 1.5 e B = 0.4. Números reais são representados com o sinal de ponto para separar a parte inteira da decimal.
Exercício 2.3
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
a) ler três números inteiros
b) calcular a média aritmética deles
c) escrever os valores lidos e o valor da média aritmética juntamente com comentários para identificá-los

4) Executar o programa com os valores 1, 2 e 3. Em seguida, analisar o resultado da média fornecido pelo programa comparando-o com o valor esperado obtido por um cálculo mental.
5) Repetir o item 4 para os valores 1, 1 e 2.
Exercício 2.4
a) ler o primeiro valor (inteiro) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número inteiro) entre dois termos subseqüentes da P.A., denotada por D
c) ler o número (inteiro) de termos da P.A., denotado por N
d) calcular o último termo da P.A., denotado por AN
e) calcular a soma de todos os termos da P.A., denotado por SN
f) escrever os três valores lidos e os dois calculados juntamente com comentários para identificá-los
4) Executar o programa para A1 = 1, D = 3 e N = 5. Os resultados devem ser AN = 13 e SN = 35.

Capítulo 3. Variáveis do tipo real 37
Capítulo 3. VARIÁVEIS DO TIPO REAL
Conceitos de: variáveis do tipo real, tradução de expressões algébricas em FORTRAN, mistura de variáveis do tipo inteiro com real, prioridade nas operações matemáticas
Operadores matemáticos básicos
Comando do FORTRAN: REAL
3.1 programa03c.f90
1) No Windows: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
2) Neste capítulo será usado um projeto já existente, no caso o projeto do fim do capítulo 2. Para abri-lo, deve-se executar o seguinte no Fortran:
a) File, Open Workspace
b) Indicar o diretório do projeto chamado programa03
c) Selecionar o arquivo que tem o nome do projeto e extensão 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 não 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 diretório e usar o comando Insert, Files into Project.
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03c.f90
4) Conforme é mostrado na Figura 3.1, dentro do espaço de edição do Fortran, na subjanela maior,
copiar exatamente o texto em vermelho mostrado na Tabela 3.1.
a) Nos capítulos 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 variáveis do tipo real, isto é, variáveis que podem guardar ou armazenar na memória do computador

números reais, positivos ou negativos, como 1.0, –1.0, 1.1, 3.1416 ou –0.003.
b) No FORTRAN, números reais são representados com o sinal de ponto para separar a parte inteira da decimal. Deve-se lembrar que em português se usa a vírgula com este fim.
c) A linha REAL A define a variável A como sendo do tipo real. Este comando reserva um espaço na memória do computador, utilizando o nome ou rótulo A para armazenar um valor real. As demais
linhas do programa já foram comentadas no capítulo 2.
REAL A
Tabela 3.1 Programa03c.f90.
WRITE(*,*) Entre com o valor de A = READ(*,*) A
WRITE(*,*) Valor de A = , A
END
Figura 3.1 Programa03c.f90.
6) Executar Build, Compile para compilar o programa
a) Na primeira linha, o comentário Entre com o valor de A, resultado do comando WRITE(*,*) Entre com o valor de A do programa.

b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor 1 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Valor de A = e o valor da variável A, resultado do comando WRITE(*,*) Valor de A = , A do programa. Deve-se notar que foi fornecido um valor inteiro para a variável A, no caso 1. Mas o resultado do programa mostra o valor 1.000000 porque a variável A é do tipo real.
d) Na quarta linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer
tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
Figura 3.2 Resultado da execução do programa03c.f90 com A = 1.
9) Executar novamente o programa, através de Build, Execute, com A = –0.0031. Junto a um número real, a letra E é usada para representar números muito grandes ou muito pequenos através da chamada notação científica ou exponencial. Desta forma, o valor –3.100000E-03 da variável A, mostrado na Figura 3.3, significa –3.1x10-3, que é igual a –0.0031.
Figura 3.3 Resultado da execução do programa03c.f90 com A = –0.0031.
10) Executar novamente o programa, através de Build, Execute, com A = 1.0E+2. Pode-se fornecer dados ao programa usando a notação científica ou exponencial, como no exemplo mostrado na Figura
3.4, onde A = 1.0E+2 = 1.0x102 = 100 = 1.0E2 = 1E2.

Figura 3.4 Resultado da execução do programa03c.f90 com A = 1.0E+2.
3.2 programa03d.f90
1) Nesta seção será usado um projeto já existente, no caso o projeto da seção anterior. Portanto, deve-se executar o seguinte no Fortran:
a) Clicar sobre o nome do programa-fonte
b) Edit, Cut para retirar o programa-fonte do projeto.
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03d.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho
mostrado na Tabela 3.2.
INTEGER D REAL A, B, C
Tabela 3.2 Programa03d.f90.
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

b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor 2.9 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.
c) Nas linhas seguintes, os resultados das variáveis D, B e C.
Figura 3.5 Resultado da execução do programa03d.f90.
7) Comentários sobre os resultados do programa03d.f90 mostrados na Figura 3.5:
a) Na linha D = A do programa, o valor da variável real A é atribuído à variável inteira D. Portanto, apenas a parte inteira do número A é passada à variável D, desprezando-se a parte decimal.
b) Na linha B = 1 / D do programa, o resultado da divisão do número 1 (inteiro) pela variável inteira D é atribuído à variável real B. Conforme visto no capítulo 2, o valor que resulta de um cálculo envolvendo dois números inteiros também é um número inteiro, que corresponde à parte inteira do número real equivalente ao cálculo realizado. Portanto, o resultado de 1 dividido por 2 (variável D) resulta em 0.5, que é um número real. Mas como o cálculo envolve dois números inteiros, a parte inteira do número real 0.5 é 0, que é o resultado da variável B mostrado na Figura
3.5. Assim, apenas a parte inteira da divisão 1 / D é passada à variável real B, desprezando-se a parte decimal.
c) Na linha C = 1.0 / D do programa, o resultado da divisão do número 1.0 (real) pela variável inteira D é atribuído à variável real C. Neste caso, o cálculo envolve a divisão de um número real (1.0) por um número inteiro (D). O resultado da variável C mostrado na Figura 3.5 é igual a 0.5, que é um número real. Isso ocorre porque o valor que resulta de um cálculo envolvendo um
número inteiro e um número real é um número real.
3.3 programa03e.f90

1) Nesta seção será usado um projeto já existente, no caso o projeto da seção anterior. Portanto, deve-se executar o seguinte no Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03e.f90
REAL A, B, C, D, E, F, G
Tabela 3.3 Programa03e.f90.
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

b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor 1.5 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*) Entre com o valor de B do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B, resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é necessário digitar o valor 0.4 para a variável B, por exemplo, e, em seguida, clicar na tecla enter.
e) Nas linhas seguintes, os resultados das variáveis C, D, E, F e G.
Figura 3.6 Resultado da execução do programa03e.f90.
7) Analisar cada resultado mostrado na Figura 3.6 comparando-o com o valor esperado obtido de um cálculo mental ou com o uso de uma calculadora.
8) Executar novamente o programa com outros valores para A e B. Analisar cada novo resultado comparando-o com o valor esperado obtido de um cálculo mental ou com o uso de uma calculadora.
3.4 ESCALA DE PRIORIDADES ENTRE OS OPERADORES MATEMÁTICOS
Na linguagem FORTRAN, as operações matemáticas são executadas numa seqüência lógica de acordo com uma escala de prioridades entre elas, que é apresentada na Tabela 3.4. Além disso são consideradas as regras descritas na Tabela 3.5. É importante conhecer estas prioridades e regras para se fazer corretamente a tradução de expressões algébricas em expressões na linguagem FORTRAN, dentro

de um programa-fonte. Alguns exemplos de expressões algébricas são apresentados abaixo nas Equações
(3.1) a (3.8).
Tabela 3.4 Escala de prioridades entre os operadores matemáticos básicos em FORTRAN.
Prioridade
Símbolo
Nome do símbolo
Operação
1a
( )
Parênteses
Qualquer
2a
**
Duplo asterisco
Potenciação
3a
*
/
Asterisco
Barra
Multiplicação
Divisão
4a
+

Sinal mais
Sinal menos
Adição
Subtração
Tabela 3.5 Regras adotadas nas operações matemáticas em FORTRAN.
Item
Regra
1
No caso de operações matemáticas que têm a mesma prioridade (multiplicação e divisão ou adição e subtração), executa-se primeiro o cálculo mais à esquerda
2
Parênteses são usados para que os cálculos sejam executados na ordem que se deseja. Com eles, a ordem de execução é do parênteses mais interno para o mais externo.
3
Com duas ou mais potenciações consecutivas, a ordem de execução é da direita para a esquerda.
4
O valor que resulta de um cálculo envolvendo dois números inteiros também é um número inteiro, que corresponde à parte inteira do número real equivalente ao cálculo realizado.
5
Uma operação envolvendo um número real com um número inteiro resulta num número real.
6
A atribuição de um número real a uma variável do tipo inteiro resulta num número inteiro que trunca a parte decimal do número real.
7
A atribuição de um número inteiro a uma variável do tipo real resulta num número real.
8
Quando se somam ou se subtraem dois números com magnitudes muito diferentes, é possível que o valor menor seja desprezado. A isso se denomina de erro de arredondamento ou de truncamento.
9
Espaços em branco entre variáveis, sinais de igualdade, parênteses, números ou operadores matemáticos não interferem no resultado dos cálculos. Eles têm apenas função estética.
H1 =
A + B C
(3.1)
H2 =
A + B C
(3.2)

H3 =
A + B C
(3.3)
H4 =
A + B D C
(3.4)
H5 =
A + B
C D
(3.5)
H6 =
A + BCD
(3.6)
H9 =
(C3 )2
(3.7)
H = 1 B3
(3.8)
10 3
3.5 programa03f.f90
1) Nesta seção será usado um projeto já existente, no caso o projeto da seção 3.3 deste capítulo.
Portanto, deve-se executar o seguinte no Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03f.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho mostrado na Tabela 3.6.
a) Nas duas primeiras linhas é usado o comando REAL para definir as variáveis do tipo real do programa. Num mesmo programa, pode-se usar um ou mais comandos REAL ou INTEGER.
b) A linha READ(*,*) A, C, B, D do programa é usada para ler os valores de quatro variáveis. Um único comando READ pode ser usado para a leitura de diversos valores que são atribuídos a diversas variáveis, que têm que estar separadas por vírgula.
c) As expressões em FORTRAN para as variáveis H1 a H6, H9 e H10 correspondem respectivamente às expressões algébricas dadas pelas Equações (3.1) a (3.8).

REAL A, C, B, D
Tabela 3.6 Programa03f.f90.
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 expressão em FORTRAN para a variável H7 corresponde à expressão algébrica dada pela
Equação (3.6).
e) As expressões em FORTRAN para as variáveis H11 e H12 correspondem à expressão algébrica dada pela Equação (3.8). Porém, na expressão de H12 são usados apenas números inteiros nas divisões.
f) A expressão em FORTRAN para a variável H8 corresponde a uma simples soma de dois números reais, um muito pequeno em relação ao outro.
Figura 3.7 Resultado da execução do programa03f.f90.
a) Na primeira linha, o comentário 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 pára e fica aguardando que sejam fornecidos os valores da variáveis A, C, B e D, resultado do comando READ(*,*) A, C, B, D do programa. Para que o programa continue sua execução é necessário digitar quatro valores. Cada valor digitado será atribuído respectivamente a uma das quatro variáveis, na mesma seqüência. Há várias formas de se entrar com diversos valores para um único comando READ: digitando tudo na mesma linha, com cada valor separado por vírgula ou espaço em branco; digitando cada valor e, em seguida, clicando na tecla enter; ou misturas das três formas anteriores. A primeira forma foi usada no exemplo da Figura 3.7 para se entrar com os valores 1, 2, 3 e 4, respectivamente, para as variáveis A, C, B e D.
c) Nas linhas seguintes, os resultados das variáveis H1 a H12.

8) Analisar cada resultado mostrado na Figura 3.7 comparando-o com o valor esperado obtido de um cálculo 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 variáveis A, C, B e D. Analisar cada novo resultado comparando-o com o valor esperado obtido de um cálculo 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 seção 2.8 do capítulo 2.
3.6 EXERCÍCIOS
Exercício 3.1
Escrever as expressões em linguagem FORTRAN que correspondem às seguintes expressões algébricas, onde A, B e L são números reais e I e J são números inteiros:
Para verificar se a resposta de cada item está correta, basta implementar a expressão em FORTRAN num programa e comparar seu resultado com o valor obtido com uma calculadora para a expressão algébrica correspondente. Os dois resultados devem ser iguais. Isso também vale para o próximo exercício.

Exercício 3.2
Escrever as expressões algébricas que correspondem às seguintes expressões em linguagem FORTRAN:
a) A = ( ( B**(1.0/2) ) + 5) / 100 b) A = (1.0/10) + ( B**(1/3.0) )
c) L = (1.0/(3.0I)) * ( ( (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) )
Exercício 3.3
a) ler três números reais
b) calcular a média aritmética deles
c) escrever os valores lidos e o valor da média aritmética juntamente com comentários para identificá-los
4) Executar o programa com os valores 1.0, 2.5 e 3.7. Em seguida, analisar o resultado da média fornecido pelo programa comparando-o com o valor esperado obtido com uma calculadora.
5) Repetir o item 4 para os valores 10, 1E+3 e 2E-1.
Exercício 3.4
a) ler o primeiro valor (real) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número real) entre dois termos subseqüentes da P.A., denotada por D
d) calcular o valor (real) do último termo da P.A., denotado por AN
f) escrever os três valores lidos e os dois calculados juntamente com comentários 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.

Capítulo 4. Variáveis do tipo caracter 50
Capítulo 4. VARIÁVEIS DO TIPO CARACTER
• Conceitos de: variáveis do tipo caracter, strings, funções intrínsecas
• Funções intrínsecas do FORTRAN para variáveis do tipo caracter: ADJUSTL, ADJUSTR, TRIM e
LEN
• Comando do FORTRAN: CHARACTER
4.1 programa4a.f90
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto o programa-fonte programa4a.f90
a) Nos capítulos 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 variáveis do tipo caracter ou string, isto é, variáveis que podem guardar ou armazenar comentários na memória do computador. Estes comentários podem incluir palavras, números, símbolos, espaços em branco ou frases. Alguns exemplos são (os conteúdos das variáveis estão separados por vírgula): UFPR, 5 de abril de 2004, teste de hoje, TM-102, U-20/5%, LL. As variáveis do tipo caracter também são chamadas de alfanuméricas porque envolvem letras e números.
b) No FORTRAN, o conteúdo ou string de uma variável do tipo caracter é definido entre aspas.
c) A linha CHARACTER A declara a variável A como sendo do tipo caracter. Este comando reserva um espaço na memória do computador, utilizando o nome ou rótulo A, para armazenar um único

caracter alfanumérico.
d) A linha A = UFPR, Curitiba, PR atribui o conteúdo entre aspas à variável A.
CHARACTER A
A = UFPR, Curitiba, PR
Tabela 4.1 Programa4a.f90, versão 1.
WRITE(*,*) Conteudo de A = , A
END
Figura 4.1 Programa4a.f90, versão 1.
a) Na primeira linha, o comentário 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 tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.

Figura 4.2 Resultado da execução do programa4a.f90, versão 1.
9) No FORTRAN, cada variável do tipo caracter deve ser declarada com a dimensão adequada à quantidade máxima de letras, números, espaços em branco e símbolos que ela poderá conter. Quando não se declara o tamanho, assume-se que seja apenas um caracter. Devido a isso, somente a letra U foi apresentada como conteúdo da variável A, na versão 1 do programa4a.f90, embora ela tenha sido definida com muito mais caracteres.
10) Para declarar a dimensão de uma variável do tipo caracter, basta colocar o tamanho entre parênteses
junto à palavra character, como exemplificado na versão 2 do programa4a.f90, na Tabela 4.2.
CHARACTER(50) A
A = UFPR, Curitiba, PR
Tabela 4.2 Programa4a.f90, versão 2.
END
11)Alterar a primeira linha do programa4a.f90 para ficar igual à Tabela 4.2. Compilar novamente o programa e gerar seu executável. Executar o programa. Agora, conforme a Figura 4.3, é apresentado o conteúdo completo da variável A, já que ele ocupa apenas 18 caracteres e a variável A foi
dimensionada prevendo até 50 caracteres.
Figura 4.3 Resultado da execução do programa4a.f90, versão 2.

4.2 programa4b.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa04 o programa-fonte programa4b.f90
a) A linha CHARACTER(50) A declara a variável A como sendo do tipo caracter. Este comando reserva um espaço na memória do computador, utilizando o nome ou rótulo A, para armazenar até
50 caracteres alfanuméricos.
b) O comando READ do FORTRAN também pode ser usado para atribuir “valor” ou conteúdo a uma variável do tipo caracter, desde que o conteúdo esteja entre aspas. Um exemplo é mostrado na linha READ(*,*) A.
CHARACTER(50) A
Tabela 4.3 Programa4b.f90.
WRITE(*,*) Entre com o conteudo de A = READ(*,*) A
END
a) Na primeira linha, o comentário Entre com o conteudo de A =, resultado do comando WRITE(*,*) Entre com o conteudo de A = do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar, entre aspas, um conteúdo para a variável A, por exemplo, “Teste de hoje” e, em seguida, clicar na tecla enter.
c) Na terceira linha, o conteúdo da variável A.

Figura 4.4 Resultado da execução do programa4b.f90.
8) Executar novamente o programa, através de Build, Execute, testando outros conteúdos para a variável A e vendo o resultado. Testar, por exemplo, uma frase com pelo menos duas palavras mas sem usar aspas para definir o conteúdo de A.
4.3 programa4c.f90
Fortran:
a) A linha CHARACTER(20) LOCAL, DIA declara duas variáveis, LOCAL e DIA, como sendo do tipo caracter, cada uma podendo armazenar até 20 caracteres alfanuméricos.
b) A linha CHARACTER(10) HORA declara a variável HORA como sendo do tipo caracter, podendo armazenar até 10 caracteres alfanuméricos.
c) A linha CHARACTER(90) FRASE declara a variável FRASE como sendo do tipo caracter, podendo armazenar até 90 caracteres alfanuméricos.
d) A linha FRASE = Frase: // LOCAL // , // DIA // , as // HORA // horas define o conteúdo da variável FRASE com base em alguns comentários que estão entre aspas e no conteúdo das variáveis LOCAL, DIA e HORA. Isso é possível devido ao uso do operador de concatenação cujo símbolo é composto por duas barras (//). Este operador permite juntar duas ou mais variáveis do tipo caracter.

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 comentário Entre com o local =, resultado do comando WRITE(*,*) Entre com o local = do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável LOCAL, resultado do comando READ(*,*) LOCAL do programa. Para que o programa continue sua execução é necessário digitar o conteúdo da variável LOCAL, por exemplo, “Curitiba” e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o dia =, resultado do comando WRITE(*,*) Entre com o dia = do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável DIA, resultado do comando READ(*,*) DIA do programa. Para que o programa continue sua execução é necessário digitar o conteúdo da variável DIA, por exemplo, “5 de abril de 2004” e, em seguida, clicar na tecla enter.
e) Na quinta linha, o comentário Entre com a hora =, resultado do comando WRITE(*,*) Entre com a hora = do programa.
f) Na sexta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável
HORA, resultado do comando READ(*,*) HORA do programa. Para que o programa continue sua

execução é necessário digitar o conteúdo da variável HORA, por exemplo, “10:58” e, em seguida, clicar na tecla enter.
g) Na sétima linha, o comentário Conteúdo de FRASE = e, em seguida, o conteúdo da variável
FRASE, resultado do comando WRITE(*,*) Conteudo de FRASE = , FRASE do programa e da linha anterior aonde se definiu a variável FRASE.
Figura 4.5 Resultado da execução do programa4c.f90.
8) Deve-se notar na Figura 4.5 que a escrita do conteúdo da variável FRASE ocupou mais de uma linha.
Isso ocorre devido a sua extensão ser muito grande, isto é, superior ao número disponível de colunas numa janela do tipo DOS.
9) No FORTRAN, se o conteúdo de uma variável é definido com menos caracteres do que o máximo declarado, a diferença entre os caracteres ocupados e o máximo previsto é preenchida com espaços em branco, como no conteúdo da variável FRASE. Por exemplo, a variável LOCAL foi declarada com tamanho máximo de 20 caracteres. Mas seu conteúdo foi definido com “Curitiba”, palavra que ocupa apenas 8 caracteres. Neste caso, os demais 12 caracteres são preenchidos com espaços em branco. O mesmo problema ocorre com as demais variáveis. Formas de se resolver este problema são abordadas na próxima seção.
10) Executar novamente o programa com outros conteúdos para as variáveis LOCAL, DIA e HORA.
4.4 programa4d.f90
1) Nesta seção será usado o mesmo projeto da seção anterior deste capítulo. Portanto, deve-se executar o seguinte no Fortran:

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 variável A como sendo do tipo caracter, podendo armazenar até 9 caracteres alfanuméricos.
b) A linha INTEGER L declara a variável L como sendo do tipo inteiro.
c) Conforme pode-se ver na Figura 4.6, ADJUSTL, ADJUSTR, TRIM e LEN estão escritos em azul dentro do Fortran. Elas são chamadas de funções intrínsecas do FORTRAN, ou seja, são funções ou comandos que existem dentro da linguagem FORTRAN. Estas funções são usadas para manipular strings, isto é, conteúdos de variáveis do tipo caracter.
d) A lista completa das funções para variáveis 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 símbolo ?InfoView; e acessar as opções Reference, Procedures, Character Procedures.
e) A linha WRITE(*,*) A =(, A, ) escreve em seqüência o conteúdo de três strings que estão separadas por vírgula. A primeira é o comentário A =(;

a segunda, o conteúdo da variável A; e a terceira, ). As quatro linhas seguintes do programa fazem o mesmo, isto é, cada uma escreve três strings em seqüência. Mas, nestes casos, em vez de escrever o conteúdo da variável A, escreve-se o resultado de alguma função operando sobre A,
conforme as explicações a seguir.
Figura 4.6 Programa4d.f90.
f) A função ADJUSTL elimina os espaços em branco que estão à esquerda de uma string e os passa à direita dela.
g) A função ADJUSTR elimina os espaços em branco que estão à direita de uma string e os passa à esquerda dela.
h) A função TRIM elimina os espaços em branco que estão à direita de uma string. i) O resultado das funções ADJUSTL, ADJUSTR e TRIM são strings.
j) A função LEN conta o número de caracteres de uma string ou variável do tipo caracter. Seu resultado é um número inteiro.
k) Na instrução TRIM(ADJUSTL(A)) do programa, a função TRIM opera sobre o resultado da função
ADJUSTL sobre a variável A.
l) Na linha L = LEN(A) do programa, a função LEN opera sobre a variável A e atribui o resultado à variável inteira L.

m) Na linha L = LEN(TRIM(ADJUSTL(A))) do programa, a função LEN opera sobre o resultado da função TRIM, que opera sobre o resultado da função ADJUSTL sobre a variável A. Finalmente, o resultado da função LEN é atribuído à variável inteira L.
a) Na primeira linha, o comentário Entre com o conteudo de A =, resultado do comando WRITE(*,*)
Entre com o conteudo de A = do programa.
Figura 4.7 Resultado da execução do programa4d.f90.
b) Na segunda linha, o comentário 0123456789, resultado do comando WRITE(*,*) 0123456789 do programa. Este comentário é uma espécie de régua para se perceber claramente o número de caracteres usados para definir a variável A, e quantos espaços em branco existem antes da string de A e depois dela. O zero é usado porque a definição da variável A exige o sinal de aspas, que não conta em seu conteúdo.
c) Na terceira linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o conteúdo da variável A, por exemplo, “ Rio 45” e, em seguida, clicar na tecla enter . Deve-se perceber que há um espaço em branco antes da palavra Rio.
d) Na quarta linha, 20 espaços em branco seguidos pelo comentário 0123456789, resultado do comando WRITE(*,*) 0123456789 do programa. Este comentário é uma espécie de régua para se perceber claramente os resultados a seguir.
e) Nas linhas seguintes, são apresentados os resultados do conteúdo da variável A e das funções ADJUSTL, ADJUSTR, TRIM e LEN operando sobre a variável A. Os sinais ( e ) marcam o ínicio e o fim de cada string.

8) Analisar cada resultado mostrado na Figura 4.7, considerando o conteúdo da variável A e as definições apresentadas acima, nesta seção, para as funções ADJUSTL, ADJUSTR, TRIM e LEN.
9) Executar novamente o programa com outros conteúdos para a variável A. Analisar os resultados de cada nova execução do programa.
10) Para concluir o uso do Fortran e do Windows, deve-se executar os passos mostrados na seção 2.8 do capítulo 2.
4.5 EXERCÍCIO
Exercício 4.1
1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos): a) declarar quatro variáveis do tipo caracter com dimensão de 5, 10, 20 e 30 caracteres b) ler o conteúdo das quatro variáveis
c) escrever o conteúdo de cada uma das quatro variáveis
d) usando o operador de concatenação, escrever combinações das quatro variáveis lidas
e) aplicar e escrever o resultado da função ADJUSTL a cada uma das quatro variáveis lidas f) aplicar e escrever o resultado da função ADJUSTR a cada uma das quatro variáveis lidas g) aplicar e escrever o resultado da função TRIM a cada uma das quatro variáveis lidas
h) aplicar e escrever o resultado da função TRIM(ADJUSTL) a cada uma das quatro variáveis lidas i) aplicar e escrever o resultado da função LEN a cada uma das quatro variáveis lidas
j) aplicar e escrever o resultado da função LEN(TRIM(ADJUSTL)) a cada uma das quatro variáveis lidas
4) Executar o programa. Em seguida, comparar os resultados escritos com o esperado para cada caso.

Capítulo 5. Arquivos e funções matemáticas intrínsecas 55
Capítulo 5. ARQUIVOS E FUNÇÕES MATEMÁTICAS INTRÍNSECAS
• Conceitos de: arquivo de saída, biblioteca, funções matemáticas intrínsecas
• Criar e usar arquivos para mostrar resultados da execução de um programa em FORTRAN
• Usar o aplicativo Notepad do Windows para mostrar o conteúdo de um arquivo durante a execução de um programa em FORTRAN
• Funções matemáticas intrínsecas do FORTRAN
• Comandos do FORTRAN: WRITE(número,*), OPEN, CLOSE, USE, SYSTEM
5.1 programa5a.f90
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto o programa-fonte programa5a.f90
a) Até aqui o comando WRITE foi utilizado com dois asteriscos dentro do parênteses, isto é, foi usado na forma WRITE(*,*). O primeiro asterisco do comando WRITE representa o “local” ou dispositivo que é usado para “escrever” algum comentário ou resultado do programa. Este asterisco pode ser substituído por um número. O número 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 número 6.
b) A única diferença entre o programa5a.f90 e o programa3c.f90, da seção 3.1 do capítulo 3, é o uso do número 6 no lugar do primeiro asterisco dos comandos WRITE.

a) Na primeira linha, o comentário Entre com o valor de A =, resultado do comando WRITE(6,*)
Entre com o valor de A = do programa.
REAL A
Tabela 5.1 Programa5a.f90.
WRITE(6,*) Entre com o valor de A = READ(*,*) A
WRITE(6,*) Valor de A = , A
END
Figura 5.1 Programa5a.f90.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor 1 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Valor de A = e o valor da variável A, resultado do comando WRITE(6,*) Valor de A = , A do programa. Deve-se notar que foi fornecido um valor inteiro para a variável A, no caso 1. Mas o resultado do programa mostra o valor 1.000000 porque a variável A é do tipo real.

d) Na quarta linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.
9) O resultado da execução do programa5a.f90 é exatamente igual a do programa3c.f90, da seção 3.1 do capítulo 3. Conforme explicado no item 5a, acima, isso ocorre devido à equivalência completa entre
os comandos WRITE(*,*) e WRITE(6,*).
Figura 5.2 Resultado da execução do programa5a.f90.
5.2 programa5b.f90
Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa05 o programa-fonte programa5b.f90
REAL A
OPEN(7, file=saida5b.txt) WRITE(7,*) Valor de A = , A CLOSE(7)
END

a) No programa5b.f90 são 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(número, file=“nome”). O comando OPEN é usado para: definir um número que será usado como referência a um arquivo; e para abrir o arquivo chamado “nome”. O número pode ser de 1 a 99 e 105 a 299. A utilização deste número num comando WRITE(número,*) resulta na escrita de comentários ou variáveis no arquivo que corresponde ao número 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 não existir, ele é criado dentro do diretório do projeto.
c) A forma do comando CLOSE que será usada neste texto é CLOSE(número). 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 são fechados ao final da execução do programa,
existindo ou não o comando CLOSE.
e) Dentro de um programa, para um mesmo número ou arquivo, a seqüência obrigatória 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 vários arquivos simultaneamente num programa.
g) A principal vantagem de se usar um arquivo é ter um registro permanente dos resultados do programa para posterior análise. Isso fica mais evidente quanto maior for a quantidade de resultados de um programa.
7) Ao se executar o programa, através de Build, Execute, surge uma janela do DOS, mostrada na
Figura 5.3, dentro da qual tem-se:
Figura 5.3 Resultado da execução do programa5b.f90 na janela DOS com A = 1.
a) Na primeira linha, o comentário Entre com o valor de A =, resultado do comando WRITE(*,*) Entre com o valor de A = do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é

necessário digitar o valor 1 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.
c) Em seguida ocorrerá a criação do arquivo saida5b.txt, dentro do diretório do projeto, como resultado do comando OPEN(7, file=saida5b.txt) do programa, uma vez que este arquivo ainda não existe quando o programa5b.f90 for executado pela primeira vez. Este comando também declara que será usado o número 7 no programa como referência ao arquivo saida5b.txt.
d) Conforme é mostrado na Figura 5.4, na primeira linha do arquivo saida5b.txt está escrito o comentário Valor de A = e o valor da variável 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 após o comando CLOSE(7)
do programa.
Figura 5.4 Resultado da execução do programa5b.f90 no arquivo saida5b.txt com A = 1.
8) A existência do arquivo saida5b.txt pode ser comprovada ao se executar Start, Programs, Windows NT Explorer. Em seguida, indicar o diretório do projeto, no caso, programa05. Finalmente, ao se clicar duas vezes sobre o nome do arquivo, ele será aberto, podendo-se ver o seu conteúdo.
9) Executar novamente o programa, através de Build, Execute, com A = −123. Neste caso, como já existe o arquivo saida5b.txt ele será usado para escrever o novo resultado do programa sobre o resultado anterior, conforme é mostrado na Figura 5.5. Ou seja, o resultado anterior, mostrado na Figura 5.4 é eliminado ou apagado. Para evitar isso, é necessário gravar os resultados em arquivos diferentes a cada execução do programa. Outra possibilidade é alterar o nome do arquivo de resultados antes do programa ser executado novamente. Executar o indicado no item anterior (8) para ver o novo conteúdo do arquivo saida5b.txt.
10) No comando OPEN também é possível especificar todo o caminho ou o diretório aonde o arquivo deve ser criado ou aberto. Quando o diretório não é especificado, por default, usa-se o diretório do projeto ou o diretório no qual o programa é executado. Por exemplo, trocar a linha OPEN(7, file=saida5b.txt), pelo seguinte: OPEN(7, file=C:Tempsaida5b.txt). Compilar novamente o programa5b.f90, gerar o seu executável, executar o programa. Usar o aplicativo

Windows NT Explorer para encontrar e abrir o arquivo saida5b.txt, que agora deverá estar no
diretório C:Temp.
Figura 5.5 Resultado da execução do programa5b.f90 no arquivo saida5b.txt com A = −123.
11) Na próxima seção, é apresentada uma forma de se automatizar a abertura do arquivo de saída. Isso permite maior rapidez na visualização dos resultados de um programa.
5.3 programa5c.f90
Fortran:
a) No programa5c.f90 são usados dois novos comandos do FORTRAN: USE e SYSTEM.
b) O comando USE biblio é usado para incluir dentro do programa uma “biblioteca” chamada biblio, onde biblio deve ser substituído pelo nome da biblioteca desejada. Uma “biblioteca”, no presente contexto, é uma coleção de comandos que não existem automaticamente dentro da linguagem FORTRAN. Todos os comandos usados até aqui, por exemplo WRITE, já existem automaticamente dentro da linguagem FORTRAN, mas o comando SYSTEM, não. Para ele ser usado é necessário incluir no programa a biblioteca aonde este comando está definido, no caso é a biblioteca chamada PORTLIB.
c) A linguagem FORTRAN permite a qualquer programador criar suas próprias bibliotecas, como será visto nos capítulos avançados deste texto.

USE PORTLIB REAL A
INTEGER VER
OPEN(7, file=saida5c.txt) WRITE(7,*) Valor de A = , A CLOSE(7)
VER = SYSTEM (Notepad saida5c.txt)
END
d) No editor do aplicativo Fortran, o comando SYSTEM não fica na cor azul por não ser um dos comandos básicos da linguagem FORTRAN. O comando SYSTEM é utilizado para executar comandos que interagem com o sistema operacional Windows. Isso permite que, durante a execução do programa escrito em FORTRAN, seja realizado o seguinte: executar outros programas ou aplicativos; criar ou deletar diretórios ou arquivos; e qualquer outro comando possível de se executar numa janela do tipo DOS. Para utilizar o comando SYSTEM deve-se definir uma variável do tipo inteiro. Depois, usar esta variável na linha do programa aonde se deseja executar o comando SYSTEM. Dentro de parênteses e aspas, deve-se incluir a seqüência de comandos que se deseja executar no Windows.
e) A linha USE PORTLIB declara que a biblioteca chamada PORTLIB será acrescentada ao programa. f) A linha VER = SYSTEM (Notepad saida5c.txt) executa o comando SYSTEM para que o aplicativo NOTEPAD do Windows abra o arquivo chamado saida5c.txt. A variável VER, usada
nesta linha, foi definida como uma variável do tipo inteiro na linha INTEGER VER do programa.
7) Ao se executar o programa, através de Build, Execute, ocorrerá exatamente o mesmo já explicado na seção anterior para o programa5b.f90. A única diferença é que quase no final da execução do programa, o arquivo de resultados, que foi denominado de saida5c.txt, será aberto automaticamente pelo aplicativo Notepad para mostrar o seu conteúdo. Ao se fechar o Notepad, a execução do programa5c.f90 será encerrada.
8) No caso do comando OPEN ser usado para especificar todo o caminho ou o diretório aonde o arquivo deve ser criado ou aberto, o comando SYSTEM também deve ser adaptado. Por exemplo, se o arquivo

saida5c.txt for criado no diretório C:Temp com o comando OPEN(7, file=C:Tempsaida5c.txt), o comando correspondente para abrir automaticamente o arquivo saida5c.txt é VER = SYSTEM (Notepad C:Tempsaida5c.txt).
5.4 programa5d.f90
1) Nesta seção será usado o mesmo projeto da seção anterior deste capítulo. Portanto, deve-se executar o seguinte no Fortran:
a) Conforme pode-se ver na Figura 5.6, ABS, LOG10, ACOS, COS e COSH estão escritos em azul dentro do Fortran. Elas são chamadas de funções intrínsecas do FORTRAN, ou seja, são funções ou comandos que existem dentro da linguagem FORTRAN. Elas são funções matemáticas usadas em cálculos que envolvem variáveis do tipo real. Outras funções são apresentadas nas Tabelas
5.5 e 5.6.
b) A lista completa de funções matemáticas intrínsecas do FORTRAN pode ser vista no manual do Fortran. Para acessá-lo, dentro da subjanela do lado esquerdo, deve-se executar: clicar uma vez sobre o símbolo ?InfoView; e acessar as opções Reference, Procedures, Numeric Procedures e as opções Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic Procedures.
a) Na primeira linha, o comentário Entre com o valor de A =, resultado do comando WRITE(*,*) Entre com o valor de A = do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor −10 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.

c) Em seguida ocorrerá a criação do arquivo saida5d.txt, dentro do diretório do projeto, como resultado do comando OPEN(8, file=saida5d.txt) do programa, uma vez que este arquivo ainda não existe quando o programa5d.f90 for executado pela primeira vez. Este comando também declara que será usado o número 8 no programa como referência ao arquivo saida5d.txt.
d) Os resultados das funções aplicadas no programa5d.f90 são mostrados na Figura 5.8.
USE PORTLIB
REAL A, B, C, Pi
INTEGER VER
OPEN(8, file=saida5d.txt)
WRITE(8,*) Valor de A = , A
B = ABS(A)
WRITE(8,*) B = Módulo de A =, B
C = LOG10(B)
WRITE(8,*) C: Logaritmo decimal de B
=,
C
Pi = ACOS(-1.0) WRITE(8,*) Pi =, Pi
D = COS(Pi)
WRITE(8,*) Cosseno de Pi =, D
D = COSH(Pi)
WRITE(8,*) Cosseno hiperbólico de Pi
=,
D
CLOSE(8)
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 variável A. Comparar cada novo resultado com o obtido de uma calculadora.
10) Os programas-executáveis também 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-executável chamado programa05.exe ou programa05.application para o diretório C:Temp. Para executar o programa, basta clicar duas vezes sobre o arquivo copiado. Como resultado, surgirá o arquivo saida5d.txt. O diretório C:Temp é apenas um exemplo. O programa-executável pode ser copiado para qualquer outro diretório e ser
executado lá.
Figura 5.6 Programa5d.f90.

Tabela 5.5 Algumas funções matemáticas do FORTRAN.
Função
Comando
Observação
Módulo 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
Mínimo
Y = MIN(X,Z,W)
Y = valor mínimo entre X, Z e W; o argumento pode conter 2 ou mais variáveis
Máximo
Y = MAX(X,Z,W)
Y = valor máximo entre X, Z e W; o argumento pode conter 2 ou mais variáveis
Tabela 5.6 Algumas funções trigonométricas do FORTRAN.
Função
Comando
Observação
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 hiperbólico
Y = SINH(X)
Cosseno hiperbólico
Y = COSH(X)
Tangente hiperbólica
Y = TANH(X)
Figura 5.7 Janela DOS do programa5d.f90.

Figura 5.8 Arquivo saida5d.txt do programa5d.f90.
5.5 EXERCÍCIOS
Exercício 5.1
a) ler o primeiro valor (real) de uma progressão aritmética (P.A.), denotado por A1
b) ler a diferença (número real) entre dois termos subseqüentes da P.A., denotada por D
d) calcular o valor (real) do último termo da P.A., denotado por AN
f) escrever no arquivo chamado saida_5p1.txt os três valores lidos e os dois calculados juntamente com comentários 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.
Exercício 5.2
a) ler algumas variáveis do tipo real
b) aplicar as funções matemáticas da Tabela 5.5 sobre as variáveis lidas
c) escrever no arquivo chamado saida_5p2.txt os valores lidos e os resultados calculados com as funções juntamente com comentários para identificá-los
4) Executar o programa. Em seguida, comparar os resultados escritos com aqueles obtidos de uma calculadora.

Exercício 5.3
a) ler algumas variáveis do tipo real
b) aplicar as funções matemáticas da Tabela 5.6 sobre as variáveis lidas
c) escrever no arquivo chamado saida_5p3.txt os valores lidos e os resultados calculados com as funções juntamente com comentários para identificá-los
4) Executar o programa. Em seguida, comparar os resultados escritos com aqueles obtidos de uma calculadora.

Capítulo 6. Formatos de edição 68
Capítulo 6. FORMATOS DE EDIÇÃO
• Conceitos e comandos de formatos de edição para variáveis do tipo inteiro, caracter e real
• Regras de edição de programas-fonte em FORTRAN
• Seqüência obrigatória dos comandos dentro de programas-fonte em FORTRAN
• Comandos do FORTRAN: WRITE(número,número) e FORMAT
6.1 FORMATOS DE EDIÇÃO PARA VARIÁVEIS 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-padrão, criar um projeto com o nome programa06
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte
programa6a.f90

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, Conteúdo de A =, A10, 1/)
WRITE(9,25) A
25 FORMAT(T10, T10, Conteúdo de A =, A10, 1/)
WRITE(9,10) A, B, C
10 FORMAT(5X, A =, A10, 1/, 5X, B =, A10, 1/, 5X, C =, A20, 2/)
WRITE(9,11) A, B, C
11 FORMAT( 5X, A =, A10, 1/,
5X, B =, A10, 1/,
5X, C =, A20, 2/ )
WRITE(9,12) A, B
12 FORMAT ( 2(A10), = variáveis A e B no formato 2(A10) ) CLOSE(9)
VER = SYSTEM(Notepad saida6a.txt)
END

a) O objetivo do programa6a.f90 é explicar alguns formatos de edição utilizados com variáveis do tipo caracter.
b) No capítulo 5, além de um asterisco, o comando WRITE foi utilizado com um número para identificar o “local” (janela ou arquivo) onde seria escrito algo, isto é, ele foi usado na forma WRITE(número1,*). Um exemplo é a linha WRITE(9,*) A, = A sem formato do programa. Agora, no programa6a.f90, o comando WRITE é utilizado com dois números, ou seja, na forma WRITE(número1,número2), por exemplo, a linha WRITE(9,21) A do programa. O número2 está associado a um novo comando do FORTRAN chamado de FORMAT.
c) O comando FORMAT é usado para especificar o formato com que comentários e conteúdos (strings ou números) de variáveis são escritos numa janela ou num arquivo. Também é usado na leitura de dados.
d) A sintaxe, isto é, a forma com que se deve usar o comando FORMAT é: número2 FORMAT (formatos). O número2 deve ser o mesmo utilizado no comando WRITE. Dentro de parênteses, deve-se especificar os formatos de edição que serão usados, separados por vírgula. Um exemplo é a linha 21 FORMAT ( A2, = A no formato A2 ) do programa, que especifica o formato A2 para escrever a variável A, do tipo caracter, chamada na linha WRITE(9,21) A do programa.
e) Os comandos FORMAT podem ser incluídos 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. Não é necessário seguir qualquer ordenamento para os números usados nos comandos FORMAT, nem para suas posições relativas dentro do programa-fonte. E não existe qualquer relação entre os números usados em comandos OPEN e os números usados nos comandos FORMAT. Eles até podem ser iguais.
f) Cada tipo de variável (caracter, inteiro ou real) tem identificadores especiais para escrever seu conteúdo na forma desejada. Além disso, existem identificadores que facilitam a escrita de comentários e da forma ou disposição estética com que se escreve algo.
g) O identificador de variáveis do tipo caracter é a letra A seguida de um número que especifica a quantidade máxima de caracteres para escrever cada variável. Dentro deste espaço, o conteúdo de cada variável do tipo caracter é escrito da esquerda para a direita. Se o conteúdo da variável ocupa mais espaço do que o reservado para escrevê-la, a parte excedente não é 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 variável do tipo caracter.
h) Dentro de um comando FORMAT, isto é, entre parênteses, pode-se escrever um ou mais comentários, 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 espaços em branco entre dois formatos de edição. Ele é usado na forma NX, onde N é um número que representa a quantidade de espaços em branco. Um exemplo é a linha 24 FORMAT(10X, 10X, Conteúdo de A =, A10, 1/) do programa, onde usou-se o formato 10X.
j) Nesta mesma linha do programa há o formato de edição N/, onde N é um número que representa a quantidade de linhas que o cursor descerá quando encontrar este formato. Neste caso, uma linha, devido ao formato 1/.
k) O identificador T, de tabulação, é usado para se escrever algo a partir de uma coluna específica, onde a coluna 1 fica na margem esquerda. Ele é usado na forma TN, onde N é o número 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, Conteúdo 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 variáveis. Neste caso, cada variável será escrita com o formato que estiver na mesma seqüência dos comandos WRITE e FORMAT. Por exemplo, na linha WRITE(9,10) A, B, C do programa, escreve-se as variáveis A, B e C com o formato número 10, que corresponde à linha 10 FORMAT(5X, A =, A10, 1/, 5X, B =, A10, 1/, 5X, C =, A20, 2/) do programa. Portanto, a primeira variável (A) será escrita com o formato A10, que é o primeiro formato de edição de variáveis que aparece no comando FORMAT. E as variáveis B e C serão escritas com os formatos A10 e A20, respectivamente, que são o segundo e o terceiro formatos de variáveis no comando FORMAT.
m)O comando FORMAT identificado pelo número 10 no programa tem exatamente a mesma função que o comando FORMAT identificado pelo número 11. A única diferença é na edição do programa-fonte. No 10 FORMAT, todos os formatos de edição usam apenas uma linha do programa-fonte. Já no 11 FORMAT, são usadas três linhas. Neste caso, quando um mesmo comando precisa ou se quer empregar mais de uma linha por motivos estéticos, usa-se o símbolo
, ao final de cada linha do programa-fonte, para indicar que o comando continua na linha seguinte. Isso vale para qualquer comando do FORTRAN.
n) O formato M(AN) é equivalente a M vezes o formato AN, onde N é o número de caracteres reservados para se escrever uma variável do tipo caracter. Por exemplo, na linha 12 FORMAT (
2(A10), = variáveis A e B no formato 2(A10) ) do programa usa-se duas vezes o
formato A10 para se escrever duas variáveis do tipo caracter.
8) Ao se executar o programa, através de Build, Execute, surge uma janela do DOS, mostrada na Figura

6.1, dentro da qual tem-se:
a) Na primeira linha, o comentário Variaveis do tipo caracter, resultado do comando WRITE(*,*) Variaveis do tipo caracter do programa.
b) Na segunda linha, o comentário 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 pára e fica aguardando que sejam fornecidos os conteúdos das variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa continue sua execução é necessário digitar “Rio 45”, “Teste”, por exemplo, e, em seguida, clicar na tecla enter.
d) Em seguida ocorrerá a criação do arquivo saida6a.txt, dentro do diretório do projeto, como resultado do comando OPEN(9, file=saida6a.txt) do programa, uma vez que este arquivo ainda não existe quando o programa6a.f90 for executado pela primeira vez. Este comando também declara que será usado o número 9 no programa como referência ao arquivo saida6a.txt.
e) Como resultado da linha VER = SYSTEM(Notepad saida6a.txt) do programa, o aplicativo Notepad abre automaticamente o arquivo saida6a.txt cujo conteúdo é mostrado na Figura 6.2. Na segunda e terceira linha do arquivo saida6a.txt o conteúdo da variável 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 espaço para escrever
o conteúdo de cada variável.
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 conteúdos para as variáveis A e B. Analisar os novos resultados.
6.2 FORMATOS DE EDIÇÃO PARA VARIÁVEIS 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), = variáveis A, B e C no formato 3(I10) )
END
a) O objetivo do programa6b.f90 é explicar alguns formatos de edição utilizados com variáveis 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 variáveis do tipo inteiro é a letra I seguida de um número que especifica a quantidade máxima de algarismos ou colunas para escrever cada variável. Dentro deste espaço, o conteúdo de cada variável do tipo inteiro é escrito da direita para a esquerda. Uma coluna é usada para o sinal do número inteiro. Se o valor inteiro da variável ocupar mais espaço, colunas ou algarismos do que o reservado para escrevê-la, no lugar do número serão apresentados apenas asteriscos. Isso significa que o formato utilizado é incompatível com o valor da variável. Um exemplo de uso deste identificador é I5 na linha 22 FORMAT ( I5, = A no formato I5 ) do programa.
d) Os identificadores X, para espaços em branco, T, para tabulação, e N/, para o cursor descer N linhas, explicados na seção 6.1 para variáveis do tipo caracter, também se aplicam com variáveis 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 número de colunas ou algarismos reservados para se escrever uma variável do tipo inteiro. Por exemplo, na linha 9 FORMAT ( 3(I10), = variáveis A, B e C no formato 3(I10) ) do programa usa-se três vezes o formato I10 para se escrever três variáveis do tipo inteiro.
a) Na primeira linha, o comentário Variaveis do tipo inteiro, resultado do comando WRITE(*,*) Variaveis do tipo inteiro do programa.
b) Na segunda linha, o comentário Entre com os valores de A e B, resultado do comando
WRITE(*,*) Entre com os valores de A e B do programa.
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa continue sua execução é necessário digitar 111 222, por exemplo, e, em seguida, clicar na tecla enter.
d) Em seguida ocorrerá a criação do arquivo saida6b.txt, dentro do diretório do projeto, como resultado do comando OPEN(9, file=saida6b.txt) do programa, uma vez que este arquivo ainda não existe quando o programa6b.f90 for executado pela primeira vez. Este comando também declara que será usado o número 9 no programa como referência ao arquivo saida6b.txt.
e) Como resultado da linha VER = SYSTEM(Notepad saida6b.txt) do programa, o aplicativo Notepad abre automaticamente o arquivo saida6b.txt cujo conteúdo é mostrado na Figura 6.4. Na segunda linha do arquivo saida6b.txt o valor da variável A (111) foi trocado por dois asteriscos. Isso ocorre porque o formato usado (I2) é incompatível para se escrever o valor da variável A, que neste caso precisa de pelo menos três colunas, ou seja, o formato mínimo seria I3. Para evitar este

tipo de problema, sempre se deve superdimensionar o espaço para escrever o valor de cada
variável.
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 variáveis A e B. Analisar os novos
resultados.
Figura 6.4 Arquivo saida6b.txt do programa6b.f90.
6.3 FORMATOS DE EDIÇÃO PARA VARIÁVEIS DO TIPO REAL: programa6c.f90
Fortran:

programa6c.f90
a) O objetivo do programa6c.f90 é explicar alguns formatos de edição utilizados com variáveis do tipo real.
b) No caso do programa6c.f90, os comandos FORMAT foram todos aglomerados no início do programa-fonte, antes mesmo de seus respectivos comandos WRITE.
c) Os dois principais identificadores de variáveis do tipo real são representados pelas letras F e E.
d) O formato de ponto flutuante é usado para números reais. Ele é denotado por FX.Y, onde Y é um número que equivale à quantidade de algarismos usados para representar a parte decimal do valor da variável. X é um número que equivale à quantidade total de colunas usadas para representar o valor da variável, incluindo seu sinal, o ponto decimal e a parte decimal. O número X sempre tem
que ser maior do que Y. No programa, por exemplo, são 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), = variáveis 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)
CLOSE(9)
A,
B,
C
VER = SYSTEM(Notepad saida6c.txt) END
e) O formato exponencial também é usado para números reais. Ele é denotado por EX.Y, onde Y é um número que equivale à quantidade de algarismos usados para representar a parte decimal do valor da variável. X é um número que equivale à quantidade total de colunas usadas para representar o valor da variável, 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 número 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 número 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 conteúdo de cada variável do tipo

real é escrito da direita para a esquerda. Os valores de X e Y são definidos pelo programador.
h) Os identificadores X, para espaços em branco, T, para tabulação, e N/, para o cursor descer N linhas, explicados na seção 6.1 para variáveis do tipo caracter, também se aplicam com variáveis 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), = variáveis A, B e C no formato 3(1PE15.3) ) do programa usa-se três vezes o formato 1PE15.3 para se escrever três variáveis do tipo real.
a) Na primeira linha, o comentário Variaveis do tipo real, resultado do comando WRITE(*,*) Variaveis do tipo real do programa.
b) Na segunda linha, o comentário Entre com os valores de A e B, resultado do comando
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa continue sua execução é necessário digitar −1.234 2.22, por exemplo, e, em seguida, clicar na tecla enter.
d) Em seguida ocorrerá a criação do arquivo saida6c.txt, dentro do diretório do projeto, como
resultado do comando OPEN(9, file=saida6c.txt) do programa, uma vez que este arquivo ainda não existe quando o programa6c.f90 for executado pela primeira vez. Este comando também declara que será usado o número 9 no programa como referência ao arquivo saida6c.txt.
e) Como resultado da linha VER = SYSTEM(Notepad saida6c.txt) do programa, o aplicativo
Notepad abre automaticamente o arquivo saida6c.txt cujo conteúdo é mostrado na Figura 6.6.
Dependendo do formato empregado, alguns algarismos do número real são 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 variáveis A e B. Analisar os novos resultados.
10) Num mesmo comando FORMAT, podem ser usados identificados de variáveis do tipo inteiro,
caracter e real, além de comentários, e dos formatos NX, N/ e TN.
6.4 RESUMO DE REGRAS GERAIS DE EDIÇÃO DE PROGRAMAS EM FORTRAN
1) Em cada linha do programa, tudo que estiver após o símbolo de exclamação (!) não é executado pelo programa. Serve apenas como comentário usado para esclarecer o que faz cada parte do programa. Dentro do Fortran PowerStation 4.0, todos os comentários ficam na cor verde. Linhas em branco são equivalentes a ter o símbolo (!) de comentário na primeira coluna de cada linha em branco.
2) Tudo que é criado ou definido pelo programador fica na cor preta dentro do Fortran PowerStation 4.0.
3) Todos os comandos intrínsecos da linguagem FORTRAN ficam na cor azul dentro do Fortran
PowerStation 4.0.
4) O símbolo é usado ao final de uma linha de programa para indicar que o comando iniciado numa linha contínua na linha seguinte.
5) Cada linha de programa pode usar até 132 colunas, incluindo os espaços em branco.
6) Em geral, espaços em branco têm apenas função estética no programa, não afetando os comandos ou as instruções do programador. Os espaços em branco são considerados quando usados dentro de comentários nos comandos WRITE e FORMAT.
7) Nos comandos da linguagem FORTRAN e em nomes de variáveis, não existe distinção entre letras maiúsculas ou minúsculas. Por exemplo, WRITE, write, Write e wRiTe são equivalentes. A distinção entre letras minúsculas e maiúsculas existe dentro de comentários nos comandos WRITE e FORMAT.

8) Na linguagem FORTRAN, os nomes de variáveis podem ter até 31 caracteres que incluem combinações das 26 letras do alfabeto, dos algarismos 0, 1, 2, 3 a 9, e o traço de sublinhado. Não é permitido acentuação e todas as variáveis devem começar por uma letra. Exemplos de nomes de variáveis (separadas por vírgula): v, va, variavel, variavel_2, variavel_31, nome03, nome_03, nome_da_rua.
6.5 SEQÜÊNCIA OBRIGATÓRIA DE COMANDOS EM FORTRAN
Até este capítulo foram vistos comandos da linguagem FORTRAN que podem ser divididos em cinco tipos:
1) Comando para inclusão de biblioteca no programa-fonte: USE
2) Comandos para declarar tipos de variáveis: INTEGER, REAL e CHARACTER
3) Outros comandos intrínsecos (WRITE, READ, OPEN, CLOSE) ou não do FORTRAN (SYSTEM), funções intrínsecas (LOG, TRIM etc) e qualquer outro comando criado pelo programador, por exemplo, cálculos e operações com strings
4) Comando de encerramento do programa-fonte: END
5) Comando de edição: FORMAT
Se todos os cinco tipos de comandos forem usados simultaneamente num programa-fonte, a seqüência obrigatória entre eles é exatamente a apresentada acima, exceto para o quinto tipo. O comando FORMAT pode ficar em qualquer lugar do programa-fonte entre os comandos USE e END.
Para os comandos do tipo 2 (INTEGER, REAL e CHARACTER), a ordem entre eles pode ser qualquer. O mesmo se aplica para os comandos do tipo 3, exceto com arquivos nos quais para um arquivo específico a seqüência obrigatória é: OPEN, WRITE e outros comandos, CLOSE.
Encerrar a sessão seguindo o procedimento-padrão.
6.6 EXERCÍCIOS
Exercício 6.1
Editar um programa-fonte em FORTRAN para realizar um cálculo de interpolação linear executando o seguinte algoritmo (passos):
1) Ler os valores de duas variáveis do tipo real, chamadas X1 e X2, que correspondem a dois dados tabelados de uma variável independente
2) Ler os valores de duas variáveis do tipo real, chamadas Y1 e Y2, que correspondem a dois dados tabelados de uma variável dependente de X
3) Ler o valor de uma variável do tipo real, chamada X, para o qual se deseja realizar a interpolação

4) Calcular o valor da variável Y, em função do valor de X, usando interpolação linear
5) Utilizando comandos FORMAT, escrever no arquivo chamado saida_6p1.txt os cinco valores lidos e o resultado de Y, juntamente com comentários para identificá-los
6) Executar o programa para X1 = 10, X2 = 20, Y1 = 100, Y2 = −20 e X = 12. O resultado deve ser Y =
76.
Exercício 6.2
Editar um programa-fonte em FORTRAN para realizar cálculos com uma progressão geométrica (P.G.)
executando o seguinte algoritmo (passos):
1) Ler o primeiro valor (real) da P.G., denotado por a1
2) Ler a razão (número real) entre dois termos subseqüentes da P.G., denotada por q
3) Ler o número (inteiro) de termos da P.G., denotado por N
4) Calcular o valor (real) do último termo da P.G., denotado por an
5) Calcular a soma de todos os termos da P.G., denotado por Sn
6) Utilizando comandos FORMAT, escrever no arquivo chamado saida_6p2.txt os três valores lidos e os dois calculados, juntamente com comentários para identificá-los
7) Executar o programa para a1 = 1.5, q = 1.1 e N = 20. Os resultados devem ser aproximadamente an ≈
9.174 e Sn ≈ 85.91.

Capítulo 7. Decisões e opções 83
Capítulo 7. DECISÕES E OPÇÕES
• Conceitos de: decisão, condição, operadores relacionais e lógicos, e opção
• Comandos do FORTRAN: IF – THEN – ELSE – END IF, SELECT CASE – CASE – END SELECT
7.1 programa7a.f90
programa7a.f90
a) Nesta e na próxima seção são vistas três 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 decisões com base em condições. Se as condições são satisfeitas, executa-se o comando que está na mesma linha do IF, caso contrário, não.
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á após o parênteses, no caso, escrever um comentário. Aquilo que está dentro de parênteses é chamado de condição, que pode ser simples ou composta. Para definir as condições, são usados os chamados operadores relacionais (Tabela 7.3) e lógicos (Tabela 7.4).
c) Na linha IF ( (A 0) .AND. (B 0) ) WRITE(*,*) A E B sao numeros NEGATIVOS do programa, tem-se um exemplo de condição composta. Cada condição simples é unida pelos operadores lógicos .AND. e .OR., que em português significam E e OU.
d) Nas condições, além de variáveis, podem ser usados diretamente valores ou expressões envolvendo valores e variáveis.
e) Nas demais linhas do programa, são testados todos os operadores relacionais e lógicos.

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 ( condições ) COMANDO
onde “condições” representa uma ou várias condições que devem ser satisfeitas para que COMANDO seja executado.
a) Na primeira linha, o comentário Entre com os valores de A e B, resultado do comando

b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis A e B, resultado do comando READ(*,*) A, B do programa. Para que o programa continue sua execução é necessário digitar 1.0 2.0, por exemplo, e, em seguida, clicar na tecla enter.
c) Em seguida são apresentados os comentários correspondentes aos comandos IF cujas condições 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 lógicos 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 execução do programa7a.f90, mostrados na Figura 7.1, com cada linha do programa-fonte onde exista um comando IF.
10) Executar novamente o programa com A = 1 e B = 1. Até entender, comparar os novos resultados, mostrados na Figura 7.2, com cada linha do programa-fonte onde exista um comando IF.

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 raízes de uma equação do 2o grau.

b) Nesta seção é 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 condições são satisfeitas, sejam executados diversos comandos do programa escritos em várias linhas. Se as condições não são satisfeitas, são executados os comandos que estão 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 não existir necessidade de comandos entre o ELSE e o END IF, pode-se usar a estrutura do comando IF mostrada na Tabela 7.7.
d) Recomenda-se identar, isto é, deslocar para a direita os comandos entre o IF (SE) e o ELSE (SENÃO), e entre o ELSE e o END IF, para que sejam facilmente visualizados os comandos que são ou não executados. Um exemplo desta recomendação é mostrado no programa7b.f90, na Tabela 7.5.

e) As três 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 ( condições ) THEN
BLOCO 1 (uma ou várias linhas de programa com comandos) ELSE
BLOCO 2 (uma ou várias linhas de programa com comandos) END IF
onde “condições” representa uma ou várias condições que devem ser satisfeitas para que o bloco 1 seja executado;
se as “condições” não forem satisfeitas, o bloco 2 é executado.
IF ( condições ) THEN
BLOCO (uma ou várias linhas de programa com comandos) END IF
onde “condições” representa uma ou várias condições que devem ser satisfeitas para que o bloco de linhas de programa seja executado.
a) Na primeira linha, o comentário 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 comentário A*(X**2) + B*X + C = 0, resultado do comando WRITE(*,*) A*(X**2) + B*X + C = 0 do programa.
c) Na terceira linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis A, B e C, resultado do comando READ(*,*) A, B, C do programa. Para que o programa continue sua execução é necessário digitar 1 −5 6, por exemplo, e, em seguida, clicar na tecla enter.

d) Em seguida são apresentados os resultados correspondentes ao bloco do programa selecionado em
função da condição 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 execução do programa7b.f90, mostrados na Figura 7.4, com cada linha do programa-fonte.
9) Executar novamente o programa com A = 1, B = −6 e C = 10. Até entender, comparar os novos
resultados, mostrados na Figura 7.5, com cada linha do programa-fonte.
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 opção entre várias e executar o bloco de linhas ou comandos do programa correspondente à opção escolhida. A opção é feita em função de uma variável do tipo inteiro ou caracter, chamada de variável seletora. Cada bloco pode conter uma ou várias linhas de programa. A sintaxe deste comando é apresentada na Tabela 7.9.
b) O número de opções existentes depende de cada caso ou programa em particular. c) A opção CASE DEFAULT é executada se nenhuma das anteriores for satisfeita.

d) Recomenda-se identar, isto é, deslocar para a direita cada opção (CASE) e cada bloco para que sejam facilmente visualizados os comandos ligados a cada opção. Um exemplo desta recomendação é mostrado no programa7c.f90, na Tabela 7.8.
e) Deve-se notar que em todos os comandos WRITE não é usado o valor da variável 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 vírgula ou, ainda, um intervalo de valores separados por dois pontos;
apenas o bloco de comandos correspondente ao “valor” da variável é executado.
A variável de seleção pode ser do tipo inteiro ou caracter. No caso de variável caracter, os “valores” devem ser strings entre aspas.
a) Na primeira linha, o comentário Entre com o valor inteiro de A, resultado do comando
WRITE(*,*) Entre com o valor inteiro de A do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor −10 para a variável A, por exemplo, e, em seguida, clicar na tecla enter.

c) Na terceira linha, é mostrado um comentário correspondente à opção selecionada em função do valor da variável A.
8) Até entender, verificar se o resultado da execução do programa7c.f90, mostrado na Figura 7.6, está correto em função do valor da variável A e o comentário correspondente à opção selecionada.
9) Executar novamente o programa com A = 2. Até entender, verificar se o novo resultado da execução do programa7c.f90 está correto em função do valor da variável A e o comentário correspondente à opção 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 sessão seguindo o procedimento-padrão.
Figura 7.6 Resultado do programa7c.f90 para A = −10.
7.4 EXERCÍCIOS
Exercício 7.1
Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):
1) Ler os valores inteiros de três variáveis, denotadas por A, B e C
2) Determinar qual das variáveis tem o menor e o maior valor
Exercício 7.2
Alterar o programa7b.f90 para que não ocorra erro de execução quando o usuário entrar com valor nulo para a variável A, e que seja calculado e escrito o valor da única raiz deste caso.
Exercício 7.3
Editar um programa-fonte em FORTRAN para calcular as raízes de uma equação algébrica cúbica.
Exercício 7.4

1) Mostrar na tela uma lista com pelo menos 4 opções de cálculo: 1 = módulo de A; 2 = raiz quadrada de
A; 3 = exponencial de A; 4 = logaritmo de A
2) Ler o valor da opção de cálculo desejada
3) Ler o valor real da variável A
4) Calcular o resultado de A para a opção escolhida pelo usuário
5) Mostrar o resultado de A

Capítulo 8. Ciclos 94
Capítulo 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 são usados dois novos comandos do FORTRAN: DO e END DO, que definem um ciclo. Ele são usados para executar várias vezes uma ou mais linhas do programa. Explicações gerais sobre o seu funcionamento são apresentadas na próxima seção.
6) Executar Build, Compile para compilar o programa. 7) Gerar o programa-executável fazendo Build, Build.

a) Na primeira linha, o valor corrente ou atual da variável A na memória do computador, resultado do comando WRITE(*,*) Valor de A antes do ciclo =, A do programa. O valor escrito,
20, é resultado da linha anterior do programa, A = 20.
b) Da segunda à décima-primeira linha, o programa executa 10 vezes a linha WRITE(*,*) Valor de A dentro do ciclo =, A porque ela está dentro de um ciclo definido pelos comandos DO e END DO. Deve-se notar que o valor da variável A muda a cada repetição do ciclo.
c) Na décima-segunda linha, o programa escreve o valor da variável A como resultado da linha
WRITE(*,*) Valor de A depois do ciclo =, A , que já está fora do ciclo.
Figura 8.1 Resultado do programa8a.f90.
9) Explicações gerais sobre o funcionamento de um ciclo em FORTRAN são 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
WRITE(*,*) Valor de A depois do ciclo =, A
END
a) Neste programa são 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 estão entre os comandos DO e END DO são executadas diversas vezes.
b) A definição de um ciclo envolve quatro variáveis do tipo inteiro: A, INICIO, FIM e PASSO. Os nomes delas podem ser outros quaisquer. Quando a execução do programa chega a um comando DO, a seqüência é a seguinte:
b.1) A variável A assume o valor da variável INICIO
b.2) Verifica-se se deve-se entrar ou não no ciclo em função dos valores das variáveis
INICIO, FIM e PASSO, conforme explicação do item c abaixo b.3) No caso de se entrar no ciclo:
b.3.1) São 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 variável A passa a ser A = A + PASSO
b.3.4) Retorna-se ao item b.2 acima

b.4) No caso de não se entrar no ciclo, a execução do programa passa diretamente à linha que estiver abaixo do comando END DO
Tabela 8.3 Sintaxe do comando DO.
DO A = INICIO, FIM, PASSO
BLOCO (uma ou várias linhas de programa com comandos) END DO
onde os valores das variáveis INICIO, FIM e PASSO devem ter sido definidos antes da execução do programa chegar ao comando DO.
c) O número de execuções (variável C) do ciclo depende das variáveis do tipo inteiro INICIO, FIM e
PASSO, calculado através de
B = FIM
− INICIO +
PASSO
PASSO
(8.1)
C = MAX ( B, 0 )
(8.2)
onde o resultado da função MAX(B,0) é o maior valor entre a variável B e o valor zero. O resultado de C pode ser 0, 1, 2, 3 etc. Portanto, o ciclo pode ser executado uma vez, diversas vezes ou nenhuma vez.
d) O valor da variável PASSO pode ser positivo ou negativo; nulo, não. Portanto, pode-se ter um ciclo cujo valor de A é progressivo (PASSO 0) ou regressivo (PASSO 0). Se PASSO = 1, seu valor não precisa ser declarado no comando DO.
e) O valor da variável A não pode ser alterado nas linhas que estão entre os comando DO e END DO. Se isso for feito, resultará num erro de compilação.
f) Recomenda-se identar, isto é, deslocar para a direita todas as linhas do programa que estão entre os comandos DO e END DO para que facilmente se perceba os comandos que compõem o ciclo. Exemplos desta recomendação são mostrados no programa8a.f90 (Tabela 8.1) e no programa8b.f90 (Tabela 8.2).

a) Na primeira linha, o comentário Entre com os valores inteiros de A, INICIO, FIM e PASSO, resultado do comando WRITE(*,*) Entre com os valores inteiros de A, INICIO, FIM e PASSO do programa.
b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis A, INICIO, FIM e PASSO, resultado do comando READ(*,*) A, INICIO, FIM, PASSO do programa. Para que o programa continue sua execução é necessário digitar 20 1 10 1, por exemplo, e, em seguida, clicar na tecla enter.
c) Em seguida são apresentados os resultados correspondentes à execução 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 explicações descritas no item 4 acima. Deve-se notar que o ciclo do programa8b.f90 é idêntico ao do programa8a.f90, Figura 8.1, devido aos valores usados para as variáveis INICIO, FIM e PASSO. Neste caso tem-se um ciclo progressivo, pois PASSO 0.
9) Executar novamente o programa com A = 20, INICIO = −5, FIM = 5 e PASSO = 1. Neste caso tem-se um ciclo progressivo, pois PASSO 0. Até entender, analisar os novos resultados, mostrados na Figura 8.3, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
10) Executar novamente o programa com A = 20, INICIO = 20, FIM = 11 e PASSO = −1. Neste caso tem-se um ciclo regressivo, pois PASSO 0. Até entender, analisar os novos resultados, mostrados na Figura 8.4, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.

Figura 8.3 Resultado do programa8b.f90 para A = 20, INICIO = −5, FIM = 5 e PASSO = 1.
Figura 8.4 Resultado do programa8b.f90 para A = 20, INICIO = 20, FIM = 11 e PASSO = −1.
11) Executar novamente o programa com A = 20, INICIO = 12, FIM = 15 e PASSO = 2. Neste caso tem-se um ciclo progressivo, pois PASSO 0. Até entender, analisar os novos resultados, mostrados na Figura 8.5, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
12) Executar novamente o programa com A = 20, INICIO = 11, FIM = 20 e PASSO = −1. Neste caso tem-se um ciclo regressivo, pois PASSO 0. Até entender, analisar os novos resultados, mostrados na Figura 8.6, considerando cada linha do programa-fonte e as explicações descritas no item 4 acima.
8.3 programa8c.f90
Fortran:

Figura 8.5 Resultado do programa8b.f90 para A = 20, INICIO = 12, FIM = 15 e PASSO = 2.
Figura 8.6 Resultado do programa8b.f90 para A = 20, INICIO = 11, FIM = 20 e PASSO = −1.
programa8c.f90
a) No programa8c.f90 é usado um novo comando do FORTRAN: EXIT. Este comando é empregado para que a execução de um ciclo seja interrompida e a execução do programa continue na linha seguinte ao comando END DO.
b) No programa8c.f90 também é exemplificado o uso da variável A em operações ou cálculos dentro de um ciclo. Conforme já foi mencionado, o valor de A não pode ser alterado por comandos dentro do ciclo. Mas o valor que a variável A assume a cada execução do ciclo pode ser usado em outros cálculos ou variáveis.
c) No caso, a variável SOMA é zerada antes do início do ciclo. A cada execução do ciclo, seu valor é alterado com o valor atual da variável A. O mesmo ocorre com a variável CUBO.

d) Quando a condição estipulada na linha IF ( SOMA FIM ) EXIT do programa for satisfeita, o comando EXIT será executado. Em seguida, a execução do programa é transferida para a linha WRITE(*,*) Valor de A depois do ciclo =, A do programa, que é a linha seguinte ao 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
DO A = INICIO, FIM, PASSO SOMA = SOMA + A
CUBO = CUBO + A**3
WRITE(*,*) A, SOMA, CUBO =, A, SOMA, CUBO IF ( SOMA FIM ) EXIT
END DO
WRITE(*,*) Valor de A depois do ciclo =, A END
a) Na primeira linha, o comentário 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.
b) Na segunda linha, o programa pára e fica aguardando que sejam fornecidos os valores das variáveis INICIO, FIM e PASSO, resultado do comando READ(*,*) INICIO, FIM, PASSO do programa. Para que o programa continue sua execução é necessário digitar 1 10 1, por exemplo, e, em seguida, clicar na tecla enter.
c) Em seguida são apresentados os resultados correspondentes à execução do programa.

8) Até entender, analisar os resultados do programa8c.f90, mostrados na Figura 8.7, considerando cada linha do programa-fonte e as explicações 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 explicações 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 EXERCÍCIOS
Exercício 8.1
1) Ler o valor inteiro de uma variável, denotada por N
2) Determinar se N é um número primo
3) Mostrar o resultado, isto é, se N é um número primo ou não.
Exercício 8.2

1) Ler o valor inteiro de uma variável, denotada por N
2) Calcular o fatorial de N apenas para N ≥ 0
3) Mostrar o resultado do fatorial de N
Exercício 8.3
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de uma progressão aritmética, cujo problema está definido no exercício 5.1
Exercício 8.4
Editar um programa-fonte em FORTRAN para calcular e escrever num arquivo o valor de cada termo de uma progressão geométrica, cujo problema está definido no exercício 6.2

Capítulo 9. Conjuntos 104
Capítulo 9. CONJUNTOS
• Conceitos de: conjunto, elemento, alocação dinâmica de memória
• Comandos do FORTRAN: DIMENSION, ALLOCATABLE, ALLOCATE, MINVAL, MAXVAL, SUM
9.1 programa9a.f90
programa9a.f90
5) Objetivos do programa:
a) Utilizar três novos comandos do FORTRAN: DIMENSION, ALLOCATABLE e ALLOCATE
b) Determinar os valores mínimo e máximo e a média de um conjunto de variáveis do tipo real
a) Todas as variáveis do tipo inteiro, real e caracter que foram empregadas até o capítulo 8 podem ser denominadas de variáveis simples. Mas também existem as chamadas variáveis compostas ou do tipo conjunto, que são o tema deste capítulo 9.
b) Neste programa são usados três novos comandos do FORTRAN: DIMENSION, ALLOCATABLE e ALLOCATE, que são empregados com variáveis do tipo conjunto. A sintaxe deles, isto é, a forma de utilizá-los é mostrada na Tabela 9.2.
c) Em FORTRAN, conjunto é uma coleção de variáveis do mesmo tipo que são agrupadas numa única variável. Cada variável que compõe o conjunto é denominada de elemento ou componente. Uma variável do tipo conjunto também é chamada de vetor ou variável subscrita. As variáveis do tipo conjunto podem ser compostas por variáveis do tipo inteiro, real ou caracter. Por exemplo, as diversas notas de uma prova podem ser agrupadas num único conjunto ou variável (NOTAS) para

representá-las, conforme é mostrado na Tabela 9.1.
d) O comando DIMENSION(:) é usado para definir uma variável 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)
DO NOTA = 2, QUANTIDADE_NOTAS
IF ( NOTAS(NOTA) MINIMO ) MINIMO = NOTAS(NOTA) IF ( NOTAS(NOTA) MAXIMO ) MAXIMO = NOTAS(NOTA) SOMA = SOMA + NOTAS(NOTA)
END DO
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 variável do tipo alocável, isto é, uma variável do tipo conjunto cuja quantidade de elementos que a compõe é definida posteriormente dentro do programa em função de alguma outra variável.
f) O comando ALLOCATE é usado para definir quantos elementos compõem uma variável do tipo conjunto e reservar o espaço de memória correspondente no computador. Não se pode atribuir

valores aos componentes de uma variável do tipo conjunto antes do comando ALLOCATE ter sido usado com ela.
g) Na linha REAL, ALLOCATABLE, DIMENSION(:) :: NOTAS do programa, define-se a variável chamada NOTAS com as seguintes características: do tipo conjunto, devido ao comando DIMENSION(:); do tipo alocável, devido ao comando ALLOCATABLE; e do tipo real, ou seja, cada elemento da variável NOTAS poderá conter números reais, devido ao comando REAL. O duplo dois pontos que aparece nesta linha deve ser usado quando existe mais de uma definição para uma variável, onde cada definição deve ser separada por vírgula.
h) Na linha ALLOCATE ( NOTAS (QUANTIDADE_NOTAS) ) do programa, utilizando-se o comando ALLOCATE e a variável QUANTIDADE_NOTAS, que é um dado do programa, define-se quantos elementos compõem a variável NOTAS e reserva-se o espaço de memória correspondente.
Tabela 9.2 Sintaxe de comandos para variáveis do tipo conjunto.
PARA DEFINIR O TIPO DE VARIAVÉL:
REAL, ALLOCATABLE, DIMENSION(:) :: A, B INTEGER, ALLOCATABLE, DIMENSION(:) :: A, B CHARACTER(X), ALLOCATABLE, DIMENSION(:) :: A, B
PARA ALOCAR A MEMÓRIA DOS CONJUNTOS: ALLOCATE ( A(N1), B(N2) )
onde X é um valor inteiro que define o número de caracteres, e
N1 e N2 são variáveis do tipo inteiro que definem a quantidade de elementos de cada conjunto.
i) Cada elemento de uma variável do tipo conjunto é referenciado por um número inteiro, chamado índice, que corresponde à ordem dele dentro do conjunto. Este índice deve ficar entre parênteses após o nome da variável do tipo conjunto. O índice ou o número do elemento pode ser representado por uma variável, por exemplo, na linha READ(*,*) NOTAS(NOTA) do programa, que está dentro de um ciclo. Neste ciclo, a variável NOTA corresponde a cada elemento da variável NOTAS.
j) Na linha MINIMO = NOTAS(1) do programa, está sendo inicializado o valor da variável MINIMO atribuindo a ela o valor do primeiro elemento da variável NOTAS. O mesmo ocorre nas duas linhas seguintes com as variáveis MAXIMO e SOMA.

k) No ciclo definido pela linha DO NOTA = 2, QUANTIDADE_NOTAS do programa, com o emprego de comandos IF, são determinados os valores MINIMO e MAXIMO dos elementos da variável NOTAS, assim como a SOMA dos valores de todos os elementos.
7) Algoritmo do programa:
a) Definir os tipos de todas as variáveis
b) Ler a quantidade de elementos da variável NOTAS, que é do tipo conjunto ou vetor c) Alocar a memória para a variável NOTAS
d) Ler os valores de todos os elementos da variável NOTAS
e) Determinar os valores mínimo e máximo e a média da variável NOTAS
f) Escrever e identificar os valores mínimo e máximo e a média da variável NOTAS
a) Na primeira linha, o comentário Entre com a quantidade de notas, resultado do comando
WRITE(*,*) Entre com a quantidade de notas do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável QUANTIDADE_NOTAS, resultado do comando READ(*,*) QUANTIDADE_NOTAS do programa. Para que o programa continue sua execução é necessário digitar 5, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com as notas, resultado do comando WRITE(*,*) Entre com as notas do programa.
d) Na quarta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os elementos da variável NOTAS, resultado do comando READ(*,*) NOTAS(NOTA) do programa, que está dentro de um ciclo que começa no primeiro elemento e vai até o último do conjunto. Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada vez; assim é necessário digitar cada nota e, em seguida, clicar na tecla Enter antes de se digitar uma nova nota. Usar, por exemplo, os valores 7, 8.5, 5.7, 4.9 e 9.
e) Em seguida são apresentados os resultados correspondentes à execução do programa.
11) Até entender, analisar os resultados do programa9a.f90, mostrados na Figura 9.1, considerando cada linha do programa-fonte, as explicações descritas no item 6 acima e a média obtida com o uso de uma calculadora.
12) Executar novamente o programa com outros valores. Até entender, analisar os novos resultados do programa9a.f90 considerando cada linha do programa-fonte, as explicações descritas no item 6 acima e a média obtida com o uso de uma calculadora.

9.2 programa9b.f90
1) Nesta seção será usado o programa9a.f90, da seção anterior, como base para um novo programa.
a) Selecionar todas as linhas do programa9a.f90 com o botão esquerdo do mouse b) Edit, Copy para salvar este programa-fonte na memória do computador
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 espaço de edição do Fortran, na subjanela maior, alterar o programa9a.f90 para que fique exatamente igual ao texto em vermelho mostrado na Tabela 9.3.
a) Utilizar três novas funções matemáticas intrínsecas do FORTRAN: MINVAL, MAXVAL e SUM, que são utilizadas com variáveis do tipo conjunto
b) Determinar os valores mínimo e máximo e a média de um conjunto de variáveis do tipo real
a) Neste programa emprega-se exatamente o mesmo algoritmo do programa anterior, isto é, os dois programas fazem exatamente o mesmo. A diferença é que neste programa os valores mínimo e máximo e a média de um conjunto de variáveis do tipo real são obtidos através de três novas funções matemáticas intrínsecas do FORTRAN: MINVAL, MAXVAL e SUM, que são utilizadas

com variáveis 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 três 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
DO NOTA = 1, QUANTIDADE_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 mínimo entre todos os elementos da variável do tipo conjunto A e atribui o resultado à variável simples B.
c) O comando B = MAXVAL(A) determina o valor máximo entre todos os elementos da variável do tipo conjunto A e atribui o resultado à variável simples B.
d) O comando B = SUM(A) calcula a soma dos valores de todos os elementos da variável do tipo conjunto A e atribui o resultado à variável simples B.

10) Ao se executar o programa, através de Build, Execute, ocorre o mesmo já explicado no item 10 da seção 9.1 deste capítulo, 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 operações com todos os elementos de um conjunto num único comando
b) Mostrar o uso de funções matemáticas intrínsecas do FORTRAN com variáveis do tipo conjunto c) Mostrar duas formas de escrever o conteúdo de variáveis do tipo conjunto
a) Na linha REAL, ALLOCATABLE, DIMENSION(:) :: CONJUNTO_A, CONJUNTO_B, CONJUNTO_C do programa, estão sendo definidas três variáveis (CONJUNTO_A, CONJUNTO_B e CONJUNTO_C) com as seguintes características: do tipo conjunto, devido ao comando DIMENSION(:); do tipo alocável, devido ao comando ALLOCATABLE; e do tipo real, ou seja, cada elemento das três variáveis poderá conter números reais, devido ao comando REAL.
b) Na linha CONJUNTO_B = CONJUNTO_A + 10 do programa, soma-se o valor 10 ao valor de cada elemento da variável CONJUNTO_A e atribui-se o resultado a cada elemento da variável CONJUNTO_B. Portanto, num único comando estão sendo feitos cálculos com todos os elementos de um conjunto. Para que isso seja possível, as duas variáveis do tipo conjunto têm que ter exatamente o mesmo número de elementos. Esta linha do programa poderia ser substituída de forma equivalente ao seguinte:
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS CONJUNTO_B(ELEMENTO) = CONJUNTO_A(ELEMENTO) + 10
END DO
c) Na linha CONJUNTO_C = EXP(CONJUNTO_A) do programa, calcula-se a exponencial do valor de cada elemento da variável CONJUNTO_A e atribui-se o resultado a cada elemento da variável CONJUNTO_C. Assim, num único comando estão sendo feitos cálculos com todos os elementos de um conjunto envolvendo uma função matemática intrínseca do FORTRAN, no caso a função

exponencial (EXP). Mas também podem ser usadas outras funções como aquelas apresentadas nas Tabelas 5.5 e 5.6. Esta linha do programa também poderia ser substituída de forma equivalente ao seguinte:
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS 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
DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS READ(*,*) CONJUNTO_A(ELEMENTO)
END DO
CONJUNTO_B = CONJUNTO_A + 10
CONJUNTO_C = EXP(CONJUNTO_A)
WRITE(*,*) CONJUNTO_B = , CONJUNTO_B DO ELEMENTO = 1, QUANTIDADE_ELEMENTOS
WRITE(*,20) ELEMENTO, CONJUNTO_C(ELEMENTO)
20 FORMAT(10X, CONJUNTO_C(, I2, ) = , 1PE15.3 ) END DO
END
d) Há duas formas de escrever os valores dos elementos de uma variável do tipo conjunto. A primeira é agir da mesma forma que no caso de uma variável simples. Por exemplo, como resultado da linha WRITE(*,*) CONJUNTO_B = , CONJUNTO_B do programa, serão escritos os valores de todos os elementos da variável CONJUNTO_B, na seqüência do primeiro ao último

elemento, no formato default do FORTRAN. A segunda forma é escrever o valor de cada elemento através de um ciclo, com ou sem formato de edição. Um exemplo disso é apresentado no último ciclo do programa9c.f90.
b) Ler a quantidade de elementos das variáveis do tipo conjunto
c) Alocar a memória para as três variáveis do tipo conjunto chamadas CONJUNTO_A, CONJUNTO_B e CONJUNTO_C
d) Ler os valores de todos os elementos da variável CONJUNTO_A
e) Somar o valor 10 ao valor de cada elemento da variável CONJUNTO_A e atribuir o resultado a cada elemento da variável CONJUNTO_B
f) calcular a exponencial do valor de cada elemento da variável CONJUNTO_A e atribuir o resultado a cada elemento da variável CONJUNTO_C
g) Escrever os valores de todos os elementos das variáveis CONJUNTO_B e CONJUNTO_C
a) Na primeira linha, o comentário Entre com a quantidade de elementos do CONJUNTO_A, resultado do comando WRITE(*,*) Entre com a quantidade de elementos do CONJUNTO_A do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável QUANTIDADE_ELEMENTOS, resultado do comando READ(*,*) QUANTIDADE_ELEMENTOS do programa. Para que o programa continue sua execução é necessário digitar 6, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com os valores do CONJUNTO_A, resultado do comando
WRITE(*,*) Entre com os valores do CONJUNTO_A do programa.
d) Na quarta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os elementos da variável CONJUNTO_A, resultado do comando READ(*,*) CONJUNTO_A(ELEMENTO) do programa, que está dentro de um ciclo que começa no primeiro elemento e vai até o último do conjunto. Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada vez; assim é necessário digitar cada valor e, em seguida, clicar na tecla Enter antes de se digitar um novo valor. Usar, por exemplo, os valores 1, 2, 3, 4, 5 e 6.
e) Em seguida são apresentados os resultados correspondentes à execução do programa.

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 explicações descritas no item 5 acima.
11) Executar novamente o programa com outros dados. Até entender, analisar os novos resultados considerando cada linha do programa-fonte e as explicações descritas no item 5 acima.
9.4 programa9d.f90
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 seções anteriores deste capítulo ao caso de uma progressão aritmética (P.A.) onde os valores dos elementos da variável do tipo conjunto são inteiros.
b) Ler o número de termos da progressão aritmética (P.A.)
c) Alocar a memória para a variável do tipo conjunto chamada A

d) Ler os valores do primeiro termo da P.A. e a diferença entre dois termos subseqüentes e) Calcular os valores dos termos da P.A. e atribuí-los à variável 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

8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 9.3, dentro da qual são solicitados os dados (usar, por exemplo, 10, 1 e 2) e, em seguida, apresentados os resultados da execução 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 EXERCÍCIOS
Exercício 9.1
Adaptar o programa9d.f90 para escrever os valores dos termos da progressão aritmética num arquivo, bem como a soma dos valores de todos os termos
Exercício 9.2
Adaptar o programa9d.f90 para calcular e escrever os valores dos termos de uma progressão geométrica num arquivo, bem como a soma dos valores de todos os termos
Exercício 9.3
1) Definir os tipos de todas as variáveis, sendo uma delas do tipo conjunto para caracteres, chamada
NOMES

2
2) Ler a quantidade de elementos da variável NOMES
3) Alocar a memória para a variável NOMES
4) Ler os conteúdos de todos os elementos da variável NOMES
5) Escrever num arquivo o conteúdo de cada elemento da variável NOMES
Exercício 9.4
Adaptar o programa9b.f90 para:
1) Escrever num arquivo os valores das notas e os resultados calculados
2) Calcular e escrever o desvio-padrão (D) das notas, definido por
N
Σ (Nm − Ni )
D = i=1
N
onde N é o número de notas, Nm é a média das notas, e Ni é cada nota.
Exercício 9.5
1) Ler os valores inteiros de cinco variáveis
2) Ordenar e escrever as cinco variáveis em ordem crescente de valor
3) Ordenar e escrever as cinco variáveis em ordem decrescente de valor
Exercício 9.6
1) Ler os valores inteiros de cinco variáveis
2) Determinar e escrever quais variáveis têm valor par
3) Determinar e escrever quais variáveis têm valor ímpar
4) Calcular a soma dos valores pares
5) Calcular a soma dos valores ímpares

Capítulo 10. Matrizes 117
Capítulo 10. MATRIZES
Conceitos de: conjunto multidimensional (matriz), ciclo implícito, 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 são aplicados a uma variável do tipo conjunto bidimensional, que também é 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 são necessários dois índices para localizar cada elemento em sua estrutura. Portanto, os conjuntos empregados no capítulo 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 são necessários diversos índices (2, 3, etc) para localizar cada elemento dentro deles. Em FORTRAN, os conjuntos podem ter até sete dimensões ou índices. Um exemplo de conjunto tridimensional é aquele onde se armazenam as coordenadas X, Y e Z de um sólido tridimensional.

d) Todos os conceitos vistos no capítulo 9 para conjuntos unidimensionais também são válidos para conjuntos multidimensionais.
e) O comando DIMENSION(:,:) é usado para definir uma variável 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 DO LINHA = 1, LINHAS
DO COLUNA = 1, COLUNAS
WRITE(*,1) LINHA, COLUNA, MATRIZ(LINHA,COLUNA)
1 FORMAT( 3X, MATRIZ(, I1, ,, I1, ) = , I5) END DO
END DO
END
f) Uma das principais aplicações de conjuntos uni e bidimensionais é a resolução de sistemas de
equações algébricas representados por
[A][X ] =
[B]
(10.1)

onde [A] é a matriz (conjunto bidimensional) dos coeficientes do sistema de equações; [X] é o vetor (conjunto unidimensional) incógnita, isto é, representa as variáveis a determinar com a resolução do sistema; e [B] é o vetor (conjunto unidimensional) independente, ou seja, ele contém valores conhecidos.
g) Na linha INTEGER, ALLOCATABLE, DIMENSION(:,:) :: MATRIZ do programa, define-se a variável chamada MATRIZ com as seguintes características: do tipo conjunto bidimensional (matriz), devido ao comando DIMENSION(:,:); do tipo alocável, devido ao comando ALLOCATABLE; e do tipo inteiro, ou seja, cada elemento da variável MATRIZ poderá conter números inteiros, devido ao comando INTEGER.
h) Na linha ALLOCATE ( MATRIZ ( LINHAS, COLUNAS ) ) do programa, utilizando-se o comando ALLOCATE e as variáveis LINHAS e COLUNAS, que são dados do programa, define-se, respectivamente, quantos elementos existem em cada linha e em cada coluna da variável MATRIZ e reserva-se o espaço de memória correspondente.
Tabela 10.2 Sintaxe de comandos para variáveis do tipo matriz (conjunto bidimensional).
PARA DEFINIR O TIPO DE VARIAVÉL:
REAL, ALLOCATABLE, DIMENSION(:,:) :: A, B INTEGER, ALLOCATABLE, DIMENSION(:,:) :: A, B CHARACTER(X), ALLOCATABLE, DIMENSION(:,:) :: A, B
PARA ALOCAR A MEMÓRIA DOS CONJUNTOS: ALLOCATE ( A(L,C), B(L,C) )
onde X é um valor inteiro que define o número de caracteres,
L e C são variáveis 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 variável do tipo conjunto bidimensional é referenciado por dois números inteiros, chamado índices, que correspondem à ordem dele dentro do conjunto. O primeiro índice corresponde à linha que o elemento ocupa dentro da matriz e o segundo, à coluna. Estes índices devem ficar dentro de parênteses, e separados por vírgula, após o nome da variável do tipo conjunto bidimensional. Os índices ou os números do elemento podem ser representados por variáveis, por exemplo, na linha READ(*,*) MATRIZ(LINHA,COLUNA) do programa, que está dentro de um ciclo duplo.

j) Ciclo duplo é quando tem-se um ciclo dentro de outro. São 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 estão entre os comandos DO e END DO. Assim, facilmente se percebe os comandos que compõem o ciclo. No caso de ciclos duplos, deve-se usar uma identação para cada ciclo, conforme o exemplo mostrado neste item, acima.
k) São usadas duas formas para escrever os valores dos elementos de uma variável do tipo conjunto bidimensional. A primeira é agir da mesma forma que no caso de uma variável 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 através de um ciclo duplo, com ou sem formato de edição. Um exemplo disso é apresentado no final do programa10a.f90
b) Ler a quantidade de elementos em cada linha e coluna da variável MATRIZ, que é do tipo conjunto bidimensional
c) Alocar a memória para a variável MATRIZ
d) Ler os valores de todos os elementos da variável MATRIZ
e) Escrever o conteúdo da variável MATRIZ sem utilizar formato de edição
f) Escrever os dois índices e o valor correspondente a cada elemento da variável MATRIZ utilizando formatos de edição
a) Na primeira linha, o comentário Entre com o numero de linhas da matriz, resultado do comando
WRITE(*,*) Entre com o numero de linhas da matriz do programa.

b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável LINHAS, resultado do comando READ(*,*) LINHAS do programa. Para que o programa continue sua execução é necessário digitar 3, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário 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 pára e fica aguardando que seja fornecido o valor da variável COLUNAS, resultado do comando READ(*,*) COLUNAS do programa. Para que o programa continue sua execução é necessário digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, o comentário Entre com os valores dos elementos da matriz da linha = 1, resultado do comando WRITE(*,*) Entre com os valores dos elementos da matriz da
linha =, LINHA do programa.
f) Na sexta linha, o programa pára e fica aguardando que sejam fornecidos os valores de todos os elementos da primeira linha da matriz, resultado dos comandos
READ(*,*) MATRIZ(LINHA,COLUNA) END DO
do programa, que contêm um ciclo que começa no elemento da primeira coluna e vai até a última.
Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada vez; assim é necessário digitar cada valor e, em seguida, clicar na tecla Enter antes de se digitar


5
um novo valor. Usar, por exemplo, os valores 1, 4, 2, 5, 3 e 6. Estes dados, nesta seqüência,
correspondem à seguinte matriz:
1
2
3
4


6
(10.2)
g) Em seguida são apresentados os resultados correspondentes à execução do programa.
11) Até entender, analisar os resultados do programa10a.f90, mostrados na Figura 10.1, considerando cada linha do programa-fonte e as explicações 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 explicações descritas no item 6 acima.
10.2 programa10b.f90
1) Nesta seção será usado o programa10a.f90, da seção anterior, como base para um novo programa.
a) Selecionar todas as linhas do programa10a.f90 com o botão esquerdo do mouse b) Edit, Copy para salvar este programa-fonte na memória do computador
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 espaço de edição do Fortran, na subjanela maior, alterar o programa10a.f90 para que fique exatamente igual ao texto em vermelho mostrado na Tabela 10.3.
a) Aplicar os comandos DIMENSION, ALLOCATABLE e ALLOCATE a conjuntos bidimensionais
(matrizes) do tipo real
b) Ler valores de elementos de matrizes e escrevê-los num arquivo utilizando ciclos simples e implícitos
c) Realizar operações matemáticas com matrizes

a) Com os ciclos usados no programa da seção 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 é possível porque: existe um ciclo externo, definido pela linha DO LINHA = 1, LINHAS do programa, que a cada execução percorre uma linha da matriz; e também existe um ciclo chamado de implícito na linha READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS ) do programa, que a cada execução percorre todas as colunas da matriz.
b) O chamado ciclo implícito ou aninhado é utilizado sem os comandos DO e END DO, conforme exemplificado na leitura e escrita da MATRIZ_A e na escrita da MATRIZ_B e da MATRIZ_C no
programa10b.f90.
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) ***) DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )
33 FORMAT( 10 (3X, 1PE10.3 ) ) END DO
WRITE(10,41)
41 FORMAT(1/, 3X, *** MATRIZ_B (CONSTANTE * MATRIZ_A) ***) DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_B(LINHA,COLUNA), COLUNA = 1, COLUNAS ) END DO
WRITE(10,51)
51 FORMAT(1/, 3X, *** MATRIZ_C (MATRIZ_A + MATRIZ_B) ***) DO LINHA = 1, LINHAS
WRITE(10,33) ( MATRIZ_C(LINHA,COLUNA), COLUNA = 1, COLUNAS ) END DO
CLOSE(10)
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 variável CONSTANTE e o resultado é atribuído 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 é atribuído 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 conteúdo da variável MATRIZ_A em formato de matriz através de um ciclo simples
(externo) e um ciclo implícito (interno). O formato de edição empregado 10 (3X, 1PE10.3 ) permite que sejam escritos até 10 elementos a cada linha com três colunas entre cada um (3X), utilizando o formato 1PE10.3 para números reais.
f) Com conjuntos multidimensionais, também se pode fazer simultaneamente operações com todos os elementos, conforme já visto no programa9c.f90 do capítulo 9 para conjuntos unidimensionais. Por exemplo, as cinco linhas de programa mostradas no item c acima podem ser substituídas de forma equivalente a apenas
MATRIZ_B = CONSTANTE * MATRIZ_A
E as cinco linhas de programa mostradas no item d acima podem ser substituídas de forma equivalente a apenas
MATRIZ_C = MATRIZ_A + MATRIZ_B
g) Com conjuntos multidimensionais, também se pode utilizar as funções intrínsecas das Tabelas 5.5 e 5.6, conforme já visto no programa9c.f90 do capítulo 9 para conjuntos unidimensionais.
b) Ler o valor do tipo inteiro de uma constante e a quantidade de elementos em cada linha e coluna das variáveis MATRIZ_A, MATRIZ_B e MATRIZ_C, que são do tipo conjunto bidimensional
c) Alocar memória para as três variáveis do tipo matriz
d) Ler os valores de todos os elementos da variável MATRIZ_A no formato de matriz

e) calcular o valor de cada elemento da MATRIZ_B através da multiplicação do valor de cada elemento da MATRIZ_A pela variável CONSTANTE
f) calcular o valor de cada elemento da MATRIZ_C através da adição 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 conteúdo das variáveis MATRIZ_A, MATRIZ_B e MATRIZ_C em formato de matriz com os dois índices de cada elemento
a) Na primeira linha, o comentário Entre com o valor da CONSTANTE (inteiro), resultado do comando WRITE(*,*) Entre com o valor da CONSTANTE (inteiro) do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável
CONSTANTE, resultado do comando READ(*,*) CONSTANTE do programa. Para que o programa continue sua execução é necessário digitar 5, por exemplo, e, em seguida, clicar na tecla Enter.
Figura 10.2 Janela DOS do programa10b.f90.
c) Na terceira linha, o comentário Entre com o numero de linhas das matrizes (inteiro), resultado do comando WRITE(*,*) Entre com o numero de linhas das matrizes (inteiro) do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável LINHAS, resultado do comando READ(*,*) LINHAS do programa. Para que o programa continue sua execução é necessário digitar 3, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, o comentário Entre com o numero de colunas das matrizes (inteiro), resultado do comando WRITE(*,*) Entre com o numero de colunas das matrizes (inteiro) do programa.


5
f) Na sexta linha, o programa pára e fica aguardando que seja fornecido o valor da variável COLUNAS, resultado do comando READ(*,*) COLUNAS do programa. Para que o programa continue sua execução é necessário digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
g) Na sétima linha, o comentário 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 pára e fica aguardando que sejam fornecidos os valores de todos os elementos da primeira linha da matriz; digitar 1 4, por exemplo, e, em seguida, clicar na tecla Enter. Para a segunda linha da matriz, digitar 2 5, por exemplo, e, em seguida, clicar na tecla Enter. Para a terceira linha da matriz, digitar 3 6, por exemplo, e, em seguida, clicar na tecla
Enter. Estes dados, nesta seqüência, correspondem à seguinte matriz:
1
2
3
4


6
(10.3)
i) Em seguida, o aplicativo Notepad apresenta os resultados correspondentes à execução 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 explicações 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 explicações descritas no item 7 acima.
10.3 EXERCÍCIOS
Exercício 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
Exercício 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
Exercício 10.3
Editar um programa-fonte em FORTRAN para calcular o produto de duas matrizes [A] x [B], executando o seguinte algoritmo (passos):
1) Ler os seguintes dados (suficientes para resolver o problema):
a) número de linhas da Matriz_A
b) número de colunas da Matriz_A
c) número de colunas da Matriz_B
d) Valores dos elementos da Matriz_A
e) Valores dos elementos da Matriz_B
2) Calcular o valor de cada elemento da Matriz_C que resulta do produto da Matriz_A pela Matriz_B;
para fazer isso, sugere-se analisar o produto literal entre uma matriz 2x2 com outra 2x1; depois, uma
3x2 com outra 2x2; deduzir o algoritmo e implementá-lo
3) Escrever num arquivo todos os dados lidos e a Matriz_C identificando todas as variáveis e elementos
4) Calcular a Matriz_D através da seguinte linha inserida dentro do programa-fonte: Matriz_D = MATMUL ( Matriz_A, Matriz_B )

onde o comando MATMUL é uma função intrínseca do FORTRAN que calcula o produto de duas matrizes
5) Escrever num arquivo a Matriz_D identificando seus elementos; ela deve ser idêntica à Matriz_C

Capítulo 11. Gráficos comWgnuplot 130
Capítulo 11. GRÁFICOS COM WGNUPLOT
• Aprender a utilizar o aplicativo Wgnuplot para fazer gráficos
• Aprender a utilizar o aplicativo Wgnuplot interativamente com um programa em FORTRAN
11.1 INSERÇÃO DO APLICATIVO WGNUPLOT NUM PROJETO
1)
Para acessar o programa Fortran, no Windows: Start, Programs, Fortran PowerStation
4.0,
Microsoft Developer Studio
2)
No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa11
3)
Acessar o site da disciplina em ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/
4)
Clicar com o botão do lado direito do mouse sobre o arquivo WGNUPLOT.EXE
5)
Escolher a opção Save Target As
6)
Na opção Save in, localizar o diretório do projeto
7)
Clicar no botão Save
8)
Repetir os itens 3 a 7 acima para os arquivos WGNUPLOT.HLP e WGNUPLOT.MNU
11.2 UTILIZAÇÃO BÁSICA DO WGNUPLOT
1) O Wgnuplot é um software livre utilizado para fazer gráficos bi e tridimensionais. Um manual básico sobre ele está disponível em ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/Wgnuplot.pdf
2) Para iniciar sua utilização, basta clicar duas vezes sobre o arquivo Wgnuplot.exe ou Application.
O resultado deve ser o mostrado na Figura 11.1.
3) Informações detalhadas sobre a utilização do Wgnuplot podem ser vistas no menu principal do programa, na opção Help, Index
4) Informações detalhadas sobre os comandos do Wgnuplot podem ser vistas no menu principal do programa, na opção Help, Index, commands. Escolher, por exemplo, o comando plot.
5) Para gerar um gráfico, devem ser executados os comandos adequados na chamada “linha de comando” do aplicativo Wgnuplot, que é a linha indicada por “gnuplot” na Figura 11.1, e onde o cursor fica após ser acionado o programa.

6) O comando plot é usado para mostrar o gráfico de funções definidas através de um arquivo de dados ou de funções pré-definidas no Wgnuplot ou, ainda, de funções criadas pelo usuário. Por exemplo, para visualizar o gráfico da função 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 gráfico da função seno, mostrado na Figura 11.3. Nas abscissas é apresentado x em
radianos, e nas ordenadas, o valor da função seno.
Figura 11.1 Janela inicial do aplicativo Wgnuplot, versão 3.5.
Figura 11.2 Inserção 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 gráfico, onde x1 e x2 são os valores mínimo e máximo, respectivamente. Por exemplo, para definir o intervalo dos valores de x entre os números 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 gráfico, como o set xrange, para visualizar o novo gráfico é necessário digitar replot na linha de comando e clicar na tecla Enter. Em seguida, surge o novo gráfico. 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 Gráfico da função seno conforme o comando do item 6 da seção 11.2.
8) O comando set yrange[y1:y2] é usado para definir o intervalo dos valores das ordenadas, isto é, y, mostrado no gráfico, onde y1 e y2 são os valores mínimo e máximo, respectivamente. Por exemplo, para definir o intervalo dos valores de y entre os números 0 e 1, na linha de comando do Wgnuplot, deve-se digitar set yrange[0:1]. Em seguida, clicar na tecla Enter. Para visualizar o resultado, digitar replot e, em seguida, clicar na tecla Enter.

9) O comando set grid é usado para facilitar a leitura dos valores de uma função através de uma malha ou grade no gráfico. 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. Após clicar na tecla de aspas, deve-se clicar na tecla de espaço em branco para que as aspas apareçam. 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 título para o gráfico, onde nome é o nome do título 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 também é usado para adicionar funções ou curvas a um gráfico já existente. Por exemplo, na linha de comando do Wgnuplot, digitar replot cos(x) e clicar na tecla Enter. A relação de comandos dos itens 6 a 13 desta seção inseridos no Wgnuplot pode ser vista na Figura 11.4. O gráfico correspondente é mostrado na Figura 11.5.
14) Entrar com o comando set xrange[0:1] e testar as seguintes funções:
a) plot x
b) plot x**2
15)O comando splot é usado para fazer gráficos 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 UTILIZAÇÃO DO WGNUPLOT PARA FAZER GRÁFICO DE UM ARQUIVO DE DADOS
1) O aplicativo Wgnuplot pode ser usado para fazer gráfico de um arquivo de dados. Isso será exemplificado com o arquivo dados.txt. Para criá-lo com o aplicativo Notepad, executar o seguinte:
a) Start, Programs, Accessories, Notepad

Figura 11.4 Comandos usados nos itens 6 a 13 da seção 11.2.
b) Dentro do espaço de edição do Notepad, digitar os seguintes números em duas colunas separadas por pelo menos um espaço em branco:
0 0
1 1
2 4
3 9
4 7
5 0
c) File, Save
d) Na janela “Save As”, dentro do campo “File Name”, digitar dados.txt
e) Ainda na janela “Save As”, dentro do campo “Save in:”, selecionar o diretório do projeto. Em seguida, clicar sobre o botão Save.
f) No aplicativo Notepad, executar File, Exit
2) Num arquivo de dados, o aplicativo Wgnuplot interpreta a primeira coluna como os dados do eixo x
(abscissas) e a segunda, do eixo y (ordenadas).
3) Inicializar o aplicativo Wgnuplot clicando duas vezes sobre o arquivo Wgnuplot.exe ou Application

4) Na linha de comando do Wgnuplot, digitar os seguintes comandos já vistos na seção anterior, clicando na tecla Enter após cada um deles:
set xlabel “x”
set ylabel “y”
set title “Teste do Wgnuplot”
set grid
Figura 11.5 Gráfico resultante dos comandos usados nos itens 6 a 13 da seção 11.2.
5) O comando set data style linespoints é utilizado para colocar um símbolo (círculo, quadrado etc) em cada par x-y dos dados e unir os pontos com retas entre eles. Na linha de comando do aplicativo Wgnuplot, digitar set data style linespoints e, em seguida, clicar na tecla Enter.
6) Para gerar o gráfico com as coordenadas x-y do arquivo dados.txt, na linha de comando do aplicativo Wgnuplot, digitar plot “dados.txt” e, em seguida, clicar na tecla Enter. Deverá surgir o gráfico correspondente aos comandos usados nesta seção, que é mostrado na Figura 11.6.
7) Encerrar o Wgnuplot com File, Exit

Figura 11.6 Gráfico resultante dos comandos usados nos itens 1 a 6 da seção 11.3.
11.4 UTILIZAÇÃO DO WGNUPLOT COM ARQUIVO DE COMANDOS
1) O aplicativo Wgnuplot também pode ser usado para fazer gráfico de um arquivo de dados utilizando um arquivo com os comandos do próprio Wgnuplot. Isso facilita muito a geração de gráficos de forma automatizada. A seguir, este novo procedimento é aplicado ao mesmo exemplo da seção anterior utilizando o arquivo comandos.txt. Para criá-lo com o aplicativo Notepad, executar o seguinte:
a) Start, Programs, Accessories, Notepad
b) Dentro do espaço de edição do Notepad, digitar os seguintes comandos do Wgnuplot:
set xlabel “x”
set ylabel “y”
set title “Teste do Wgnuplot”
set grid
set data style linespoints plot “dados.txt”
c) File, Save
d) Na janela “Save As”, dentro do campo “File Name”, digitar comandos.txt

e) Ainda na janela “Save As”, dentro do campo “Save in:”, selecionar o diretório do projeto. Em seguida, clicar sobre o botão Save.
f) No aplicativo Notepad, executar File, Exit
2) Inicializar o aplicativo Wgnuplot clicando duas vezes sobre o arquivo Wgnuplot.exe ou
Application
3) Para gerar o gráfico 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 gráfico da seção anterior, já mostrado na Figura
11.6. Deve-se notar que este novo gráfico 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 seção, 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 gráficos correspondentes utilizando arquivos de comandos (comandos.txt) do Wgnuplot. Na próxima seção é mostrado como fazer isso.
11.5 programa11.f90
1) Nesta seção será usado o mesmo projeto criado na seção 11.1. Portanto, no Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte programa11.f90
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 seção 5.3 do capítulo 5.
b) O comando SYSTEM vinha sendo usado para que o aplicativo Notepad abrisse arquivos com resultados dos programas. No programa11.f90 ele também é usado para acionar o aplicativo Wgnuplot e gerar um gráfico, com o procedimento visto na seção 11.4.
c) O arquivo de comandos do Wgnuplot utilizado no programa é aquele criado na seção anterior, chamado comandos.txt.
a) Unir a biblioteca PORTLIB ao programa para usar o comando SYSTEM

b) Definir os tipos de todas as variáveis
c) Ler o número de pontos a usar para gerar o gráfico
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 conteúdo do arquivo DADOS.TXT
f) Com o aplicativo Wgnuplot, gerar um gráfico com os dados do arquivo DADOS.TXT utilizando os comandos do arquivo COMANDOS.TXT.
USE PORTLIB REAL X, Y
INTEGER PONTO, PONTOS, VER
Tabela 11.1 Programa11.f90.
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 comentário Entre com o numero de pontos, resultado do comando
WRITE(*,*) Entre com o numero de pontos do programa.

b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável
PONTOS, resultado do comando READ(*,*) PONTOS do programa. Para que o programa continue sua execução é necessário digitar 11, por exemplo, e, em seguida, clicar na tecla Enter.
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 conteúdo é 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 gráfico mostrado na Figura 11.9.
9) Até entender, analisar os resultados do programa11.f90, mostrados nas Figura 11.7 a 11.9, considerando cada linha do programa-fonte e as explicações descritas nas seções anteriores deste capítulo.
10) Executar novamente o programa com outro número de pontos.

11.6 EXERCÍCIOS
Exercício 11.1
Adaptar o programa11.f90 para que ele gere o gráfico y versus x onde y = logaritmo decimal de x
Exercício 11.2
Adaptar o programa11.f90 para que ele gere o gráfico y versus x onde y = cosseno hiperbólico de x
Figura 11.9 Gráfico gerado com o programa11.f90.

Capítulo 12. Sub-rotinas 141
Capítulo 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-padrão, criar um projeto com o nome programa12a
principal1.f90
5) No Fortran, seguindo o procedimento-padrão, 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 são usados quatro novos comandos do FORTRAN: PROGRAM, EXTERNAL, SUBROUTINE e CALL. Eles são aplicados com o que se denomina em programação de sub- rotina.
b) Sub-rotinas são programas inseridos ou usados por um programa-principal.
c) O programa-principal é o programa-fonte que contém 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 seção 12.4 deste capítulo. Já o

segundo caso é exemplificado na presente seção 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 são 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.
PROGRAM CAPITULO_12A EXTERNAL ROTINA1
REAL A, B, C
Tabela 12.1 Programa-fonte principal1.f90.
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 contêm sub-rotinas. O programa-principal deve ser compilado por último.
f) Cada sub-rotina pode depender de variáveis do programa-principal ou pode ser um programa totalmente independente. Neste caso, com poucas adaptações, 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 são mais fáceis de implementar e que facilitam a detecção de erros.
h) Cada sub-rotina deve ter um nome específico, que é definido com o comando SUBROUTINE.
Este nome é usado para chamar ou usar cada sub-rotina no local desejado. As sub-rotinas são ativadas ou chamadas através do comando CALL.
i) As sub-rotinas podem ser escritas pelo próprio 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 início 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 não tem utilidade prática 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 contém a sub-rotina, e não 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 variáveis que estão entre parênteses, isto é, as variáveis A, B e C, que foram declaradas como variáveis reais no programa-principal.
m)Na linha SUBROUTINE SOMA ( X, Y, Z ), do programa-fonte rotina1.f90, define-se o início e o nome da sub-rotina como sendo SOMA e, ainda, quais as variáveis que são recebidas e devolvidas ao programa-principal, no caso as variáveis X, Y e Z. E na última linha, com o comando END SUBROUTINE SOMA, define-se o fim da sub-rotina SOMA.
n) As variáveis de uma sub-rotina que são recebidas e devolvidas ao programa-principal são denominadas de argumentos da sub-rotina. Elas têm que ser do mesmo tipo das variáveis usadas no programa-principal que chama a sub-rotina, mas não precisam ter o mesmo nome. Não é obrigatório 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 variáveis A, B e C como sendo do tipo real
c) No programa-principal, ler o valor das variáveis A e B
d) No programa-principal, chamar a sub-rotina SOMA, transferindo a ela os valores atuais das variáveis A, B e C

e) Na sub-rotina SOMA, receber os valores das variáveis X, Y e Z, transferidos do programa- principal
f) Na sub-rotina SOMA, realizar a soma das variáveis X e Y e atribuir o resultado à variável 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 variáveis X, Y e Z, da sub-rotina, para as variáveis A, B e C do programa-principal
h) No programa-principal, escrever o valor atual da variável C
i) No programa-principal, encerrar a execução 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.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar 1, por exemplo, e, em seguida, clicar na tecla Enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*) Entre com o valor de B do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B, resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é necessário digitar 2, por exemplo, e, em seguida, clicar na tecla Enter.
e) Na quinta linha, é apresentado o resultado da soma das variáveis A e B, calculado dentro da sub- rotina SOMA.

14) Até entender, analisar os resultados do programa12a, mostrados na Figura 12.1, considerando cada linha dos dois programas-fonte envolvidos e as explicações 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-padrão, criar um projeto com o nome programa12b
principal2.f90
PROGRAM CAPITULO_12B EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL 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.
SUBROUTINE SOMA ( X, Y, Z ) 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 constituído por uma ou várias sub-rotinas. Um exemplo é o programa-fonte rotinas2.f90 que contém 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 variável que está entre parênteses, isto é, a variável INTEIRO, que foi declarada como variável 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 variáveis A, B e C como sendo do tipo real e a variável
INTEIRO como do tipo inteiro
c) No programa-principal, ler o valor das variáveis A e B
d) No programa-principal, chamar a sub-rotina SOMA, transferindo a ela os valores atuais das variáveis A, B e C
e) Na sub-rotina SOMA, receber os valores das variáveis X, Y e Z, transferidos do programa- principal
f) Na sub-rotina SOMA, realizar a soma das variáveis X e Y e atribuir o resultado à variável 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 variáveis X, Y e Z, da sub-rotina, para as variáveis A, B e C do programa-principal
h) No programa-principal, escrever o valor atual da variável C
i) No programa-principal, ler o valor da variável INTEIRO
j) No programa-principal, chamar a sub-rotina FATORIAL, transferindo a ela o valor atual da variável INTEIRO
k) Na sub-rotina FATORIAL, receber o valor da variável N, transferido do programa-principal
l) Na sub-rotina FATORIAL, realizar o cálculo do fatorial da variável N e atribuir o resultado à variável FAT
m)Na sub-rotina FATORIAL, escrever o valor da variável 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 variável N, da sub-rotina, para a variável INTEIRO do programa-principal
o) No programa-principal, encerrar a execução do programa
9) Executar Build, Compile para compilar o programa-fonte rotinas2.f90.
11)Gerar o programa-executável fazendo Build, Build.
12)Ao se executar o programa, através de Build, Execute, obtém-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 explicações descritas nos itens 7 e 8 acima.

14) Executar novamente o programa com outros dados.
15)No Fortran, para fechar o projeto atual, executar File, Close Workspace
Figura 12.2 Resultado do programa12b.
12.3 programa12c
1) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa12c
principal3.f90
PROGRAM CAPITULO_12C EXTERNAL ROTINA3
CALL OUTRAS
END PROGRAM CAPITULO_12C
rotinas2.f90
5) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho mostrado na Tabela 12.4. O conteúdo do arquivo rotinas2.f90 também pode ser copiado diretamente do projeto anterior, programa12b.
6) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte rotina3.f90

a) Implementar um programa com três sub-rotinas divididas em dois programas-fonte b) Fazer uma sub-rotina chamar outras sub-rotinas
c) Utilizar uma sub-rotina sem argumentos
SUBROUTINE OUTRAS EXTERNAL ROTINAS2
INTEGER INTEIRO
REAL A, B, C
Tabela 12.6 Programa-fonte rotina3.f90.
CALL FATORIAL ( INTEIRO )
END SUBROUTINE OUTRAS
a) O programa12c faz exatamente o mesmo que o programa12b, da seção anterior. A diferença é que tudo o que antes era feito no programa-principal agora é feito pela sub-rotina OUTRAS, que é chamada pelo programa-principal cuja única função 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 seção 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, através de Build, Execute, obtém-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 três programas-fonte envolvidos e as explicações pertinentes.
12.4 programa12d
1) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa12d
principal4.f90
3) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho mostrado na Tabela 12.7. Deve-se perceber que quase todo o conteúdo 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 idêntico ao programa12c, da seção anterior. Há apenas duas diferenças. A primeira é que as três sub-rotinas (OUTRAS, SOMA e FATORIAL) que antes estavam dentro de dois programas-fonte (rotinas2.f90 e rotina3.f90) agora estão inseridas dentro do próprio programa-principal.
b) O comando CONTAINS do FORTRAN é usado para separar o fim do programa-principal do início das sub-rotinas contidas dentro do programa-principal, conforme pode-se ver na Tabela
12.7.
c) A segunda diferença é que, após 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 início do programa-principal foi empregado o comando USE junto com o nome da biblioteca.

d) A biblioteca MSIMSLMS contém muitas sub-rotinas com diversas finalidades. A lista completa das sub-rotinas desta biblioteca, informações 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 seção 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

CALL FATORIAL ( INTEIRO ) END SUBROUTINE OUTRAS
! ------------------------------------------------------------------- SUBROUTINE SOMA ( X, Y, Z )
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, através de Build, Execute, obtém-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 explicações pertinentes.
Figura 12.3 Resultado do programa12d.
12.5 EXERCÍCIO
Exercício 12.1
Alterar o programa12d, da seção 12.4, da seguinte forma:
1) Adaptar a sub-rotina FATORIAL e sua chamada na sub-rotina OUTRAS para que o valor do fatorial seja passado a sub-rotina OUTRAS
2) Implementar a sub-rotina ESCREVE para escrever num arquivo os resultados das variáveis A, B, C, INTEIRO e fatorial. Esta nova sub-rotina deverá ser chamada dentro da sub-rotina OUTRAS.
3) Implementar a sub-rotina ARQUIVO para mostrar, com o aplicativo Notepad, o conteúdo do arquivo criado pela sub-rotina ESCREVE. A sub-rotina ARQUIVO deverá ser chamada pela sub-rotina OUTRAS, após a chamada da sub-rotina ESCREVE.

Capítulo 13. Variáveis do tipo real dupla 154
Capítulo 13. VARIÁVEIS DO TIPO REAL DUPLA
Conceitos de: variáveis de precisão simples e dupla, variáveis do tipo real simples e dupla, mistura de variáveis do tipo inteiro com real simples e real dupla
Funções matemáticas intrínsecas e formatos de edição para variáveis do tipo real dupla
Comandos do FORTRAN: REAL, REAL*4, REAL(4), REAL*8, REAL(8), DOUBLE PRECISION e
IMPLICIT NONE
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
a) Definir uma variável do tipo real de dupla precisão usando o comando REAL*8 b) Comparar a precisão de variáveis do tipo real simples e dupla
programa13a.f90
a) No capítulo 3 foram abordadas as variáveis do tipo real. Elas são usadas para definir variáveis do tipo real, isto é, variáveis que podem guardar ou armazenar na memória do computador números reais, positivos ou negativos, como 1.0, –1.0, 1.1, 3.1416 ou –0.003. Para definir uma variável do tipo real num programa usa-se o comando REAL. As variáveis definidas com o comando REAL podem guardar na memória do computador valores no intervalo aproximado de 1.17e-38 a
3.40e+38 e a precisão é de 6 casas decimais. Estas variáveis também podem ser chamadas de reais simples ou de precisão simples.
b) O novo comando REAL*8 é usado para definir variáveis do tipo real dupla ou de precisão dupla.
As variáveis definidas com o comando REAL*8 podem guardar na memória do computador

valores no intervalo aproximado de 2.22e-308 a 1.79e+308 e a precisão é de 15 casas decimais.
Em geral, estas variáveis são mais adequadas em computação científica. Entretanto elas exigem o dobro da memória computacional em relação às variáveis reais simples.
c) A linha REAL A define a variável A como sendo do tipo real simples.
d) A linha REAL*8 B define a variável 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 A = , A WRITE(*,*) Valor de B = , B
END
8) Executar o programa, através de Build, Execute, com o valor 1 para as duas variáveis. O resultado deve ser o mostrado na Figura 13.1. Deve-se notar que o número de casas decimais da variável A (real simples) é 6, e da variável B (real dupla) é 15.
Figura 13.1 Resultado da execução do programa13a.f90 com A e B = 1.
9) Executar novamente o programa com o valor 123456789 para as duas variáveis e analisar os resultados.

10) Executar novamente o programa com o valor 0.001 para as duas variáveis e analisar os resultados.
11) Executar novamente o programa com o valor 1.2345678901234567890 para as duas variáveis e analisar os resultados. Notar que o algarismo da última casa decimal é arredondado e os algarismos excedentes são desprezados.
12) Executar novamente o programa com outros dados e analisar os resultados.
a) Usar diversas formas para definir variáveis reais simples e dupla
b) Realizar cálculos elementares envolvendo variáveis do tipo inteiro, real simples e real dupla
programa13b.f90
a) As variáveis do tipo real simples podem ser definidas através dos comandos REAL, REAL*4 e
REAL(4). Exemplos são as definições das variáveis A, B e C.
b) As variáveis do tipo real dupla podem ser definidas através dos comandos REAL*8, REAL(8) e
DOUBLE PRECISION. Exemplos são as definições das variáveis E, F e G.
c) Os cálculos das variáveis D, B e C são exatamente os mesmos mostrados no programa03d.f90 do capítulo 3, seção 3.2, para explicar as conseqüências de misturar variáveis do tipo inteiro e real simples num cálculo. Estas mesmas explicações valem para as variáveis reais dupla F e G.
d) Quando se atribui uma variável real simples a uma real dupla, esta tem sua precisão deteriorada para real simples. Um exemplo é o cálculo da variável E. Isso deve sempre ser evitado. Se o objetivo é usar precisão dupla num programa, todas as variáveis e os cálculos devem envolver precisão dupla, exceto em alguns tipos de cálculo com variáveis inteiras.
8) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A.
9) Analisar os resultados mostrados na Figura 13.2. Deve-se notar a diferença de precisão no arredondamento do cálculo das variáveis C e G. Também deve-se notar a deterioração da precisão da

variável real dupla E causada ao se igualar ela à variável real simples A: todos os algarismos que
aparecem na variável E após os zeros são lixo, também chamado de erro de arredondamento.
INTEGER D REAL A
REAL*4 B REAL(4) C
REAL*8 E REAL(8) F
DOUBLE PRECISION G
D = A
B = 1 / D
C = 1.0 / D
E = A
F = 1 / D
G = 1.0 / D
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 variável A e analisar os resultados.

Figura 13.2 Resultado da execução do programa13b.f90 com A = 6.9.
13.3 programa13c.f90
a) Mostrar a importância de serem definidas todas as variáveis de um programa b) Utilizar o comando IMPLICIT NONE
programa13c.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho mostrado na Tabela 13.2, isto é, copiar o programa13b.f90 do projeto anterior.
5) Eliminar a primeira linha do programa, ou seja, INTEGER D.
6) Executar Build, Compile para compilar o programa. Mesmo a variável D não tendo sido definida, não ocorre erro de compilação. Quando uma variável não é definida, por default, assume-se que todas as variáveis iniciadas pelas letras I até N, em ordem alfabética, são do tipo inteiro, e as demais são do tipo real simples.
8) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A. Em princípio, os mesmos resultados mostrados na Figura 13.2 deveriam ser obtidos. Porém, pode-se notar na Figura 13.3 que isso não ocorre, ressaltando-se: a variável D passou a ser uma variável real simples; com isso, foram alterados os valores das variáveis B, C, F e G.
9) Incluir na primeira linha do programa13c.f90 o comando IMPLICIT NONE. Ele deve ser colocado antes de qualquer declaração de tipo de variável. Recomenda-se fortemente sempre usar o comando IMPLICIT NONE porque ele obriga o programador a declarar explicitamente os tipos de

todas as variáveis empregadas no programa. Assim, se houver a digitação errônea do nome de uma
variável, o compilador apontará o erro.
Figura 13.3 Resultado da execução do programa13b.f90 sem definir a variável inteira D.
10) Executar Build, Compile para compilar a nova versão do programa. Deve-se notar que agora ocorrerá erro de compilação, apontando que a variável D não foi declarada.
11) Incluir a declaração da variável D como sendo do tipo inteiro, conforme é mostrado na Tabela
13.3.
14) Executar o programa, através de Build, Execute, com o valor 6.9 para a variável A. Agora os resultados são os mesmos mostrados na Figura 13.2, conforme esperado.
IMPLICIT NONE INTEGER D
REAL A REAL*4 B REAL(4) C
REAL*8 E REAL(8) F
DOUBLE PRECISION G

D = A
B = 1 / D
C = 1.0 / D
E = A
F = 1 / D
G = 1.0 / D
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 funções matemáticas intrínsecas do FORTRAN com variáveis reais do tipo dupla b) Usar formatos de edição com variáveis reais do tipo dupla
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

WRITE(9,21)
A8,
A8,
A8, A8, A8
WRITE(9,11)
A8,
B8,
C8
WRITE(9,12)
CLOSE(9)
A8,
B8,
C8
OPEN(9,file=saida13d.txt)
A4 = A8
WRITE(9,*) A4 = A8 =, A4
B4 = ABS(A4) B8 = DABS(A8)
WRITE(9,*) B4 = Módulo com ABS(A4) =, B4
WRITE(9,*) B8 = Módulo com DABS(A8) =, B8
C4 = LOG10(B4) C8 = DLOG10(B8)
WRITE(9,*) C4: Logaritmo decimal com
LOG10(B4)
=,
C4
WRITE(9,*) C8: Logaritmo decimal com
DLOG10(B8)
=,
C8
Pi4 = ACOS(-1.0e0) Pi8 = DACOS(-1.0d0)
WRITE(9,*) Pi com ACOS(-1.0e0) = ,
Pi4
WRITE(9,*) Pi com DACOS(-1.0d0) = ,
Pi8
WRITE(9,*) A8, = A8 sem formato
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), = variáveis 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 funções matemáticas intrínsecas do FORTRAN são os mesmos para variáveis reais simples ou dupla. Mas os nomes são distintos para preservar a precisão das variáveis reais dupla; em geral, acrescenta-se a letra D à frente do comando usado com variáveis do tipo real simples. Por exemplo: a função ABS(X) usada para calcular o módulo da variável 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 funções matemáticas intrínsecas do FORTRAN para variáveis do tipo real dupla. Estas tabelas são as correspondentes às Tabelas 5.5 e 5.6 para
variáveis do tipo real simples.
Tabela 13.5 Algumas funções matemáticas do FORTRAN
com argumentos e resultados sendo variáveis do tipo real dupla.
Função
Comando
Observação
Módulo 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
Mínimo
Y = DMIN1(X,Z,W)
Y = valor mínimo entre X, Z e W; o argumento pode conter 2 ou mais variáveis
Máximo
Y = DMAX1(X,Z,W)
Y = valor máximo entre X, Z e W; o argumento pode conter 2 ou mais variáveis
c) A lista completa de funções matemáticas intrínsecas do FORTRAN pode ser vista no manual do Fortran. Para acessá-lo, dentro da subjanela do lado esquerdo, deve-se executar: clicar uma vez sobre o símbolo ?InfoView; e acessar as opções Reference, Procedures, Numeric Procedures e as opções Reference, Procedures, Trigonometric, Exponential, Root, and Logathmic Procedures.
d) Os tipos de formatos de edição usados com variáveis do tipo real simples também podem ser usados com variáveis do tipo real dupla. Estes formatos foram vistos no capítulo 6, seção 6.3. Um outro formato que pode ser conveniente é 1PEX.YEZ, onde a terminação EZ indica expoente e Z o número de algarismos para o expoente. Por exemplo, no programa13d.f90 usa-se o formato
1PE15.2E3.
e) Nos argumentos de funções intrínsecas para variáveis do tipo real dupla deve-se definir os números usando-se a letra D (ou d) em vez de E (ou e) (das variáveis reais simples) para

representar o expoente. Em cálculos ou expressões que envolvam números reais, também deve-se fazer isso. Se estas recomendações não forem seguidas ocorrerá erro de compilação ou perda de precisão nos cálculos. Por exemplo, no programa13d.f90 usa-se 1.0e0 como argumento da função real simples ACOS para calcular o valor de , e 1.0d0 como argumento da função real dupla DACOS.
f) A escala de prioridades entre os operadores matemáticos e as regras adotadas nas operações matemáticas, descritas nas Tabelas 3.4 e 3.5 também se aplicam às variáveis do tipo real dupla, onde pertinente.
Tabela 13.6 Algumas funções trigonométricas do FORTRAN
com argumentos e resultados sendo variáveis do tipo real dupla.
Função
Comando
Observação
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 hiperbólico
Y = DSINH(X)
Cosseno hiperbólico
Y = DCOSH(X)
Tangente hiperbólica
Y = DTANH(X)
8) Executar o programa, através de Build, Execute, com o valor 1.234567890 para a variável A8.
9) Analisar os resultados mostrados na Figura 13.4.
10) Executar novamente o programa com outros valores para a variável A8 e analisar os resultados; por exemplo, A8 = 1e+3, 1.0d-3, 1.2e-30.
13.5 EXERCÍCIOS
Exercício 13.1
Para testar as operações matemáticas básicas, refazer o programa03e.f90, do capítulo 3, seção 3.3, usando variáveis do tipo real dupla em vez de real simples.

Exercício 13.2
Para testar o uso da escala de prioridades entre os operadores matemáticos e as regras adotadas nas operações matemáticas, descritas nas Tabelas 3.4 e 3.5, refazer o programa03f.f90, do capítulo 3, seção
3.5, usando, onde pertinente, variáveis do tipo real dupla em vez de real simples.
Figura 13.4 Resultado da execução do programa13d.f90 no arquivo saida13d.txt com A8 =
1.234567890.
Exercício 13.3
Escrever as expressões em linguagem FORTRAN que correspondem às seguintes expressões algébricas, onde A, B e L são números reais de precisão dupla, e I e J são números inteiros:

Exercício 13.4
1) Executar o programa13d.f90 com A8 = 1.2e+308. Deve-se notar que o programa terá problema durante a execução. Por que isso ocorre?
2) Implementar uma nova versão do programa13d.f90 com a eliminação de tudo relacionado às variáveis reais de precisão simples.
a) Gerar o executável desta nova versão e executá-lo com A8 = 1.2e+308. Deve-se notar que agora o programa é executado sem nenhum problema. Por que isso ocorre? Observar o que acontece com a representação dos resultados através dos formatos usados, principalmente com relação aos expoentes.
b) Executar novamente o programa com A8 = 2.2e-308.
c) Executar novamente o programa com A8 = 2.0e+308. O que acontece? Por quê?
d) Executar novamente o programa com outros valores para A8.

Capítulo 14. Arquivos de saída, de entrada e internos 165
Capítulo 14. ARQUIVOS DE SAÍDA, DE ENTRADA E INTERNOS
• Conceitos de: arquivo de entrada, arquivo interno, arquivo texto, arquivo binário, dispositivo e nome de arquivo genéricos
• Comandos do FORTRAN: uso avançado de OPEN, WRITE e SYSTEM
• No comando OPEN, usar os parâmetros FORMATTED, UNFORMATTED, REWIND e APPEND
Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows, através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
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 número do dispositivo sendo pré- definidos; e
(c) abrir o arquivo de resultados com o aplicativo Notepad.
programa14a.f90
7) Executar o programa através 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.

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 através de janela DOS;
(b) escrever resultados num arquivo cujo nome e o número do dispositivo são genéricos e definidos pelo usuário através dos dados do programa; e
(c) abrir o arquivo de resultados de nome genérico com o aplicativo Notepad.

programa14b.f90
INTEGER UNIT, VER CHARACTER(50) SAIDA, TEXTO
Pi = DACOS(-1.0d0)
Tabela 14.2 Programa14b.f90
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 número do dispositivo que identifica o arquivo, é usado uma variável chamada UNIT, que é um dado do programa. E o nome do arquivo, que aparece após a palavra-chave FILE, também é uma

variável, chamada SAIDA, que é definida pelo usuário através dos dados do programa; observa- se que não se deve usar apóstrofos ou aspas com esta variável, como era feito antes, por exemplo no programa14a.f90. Os nomes das variáveis 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 número do dispositivo que identifica o arquivo, é usado uma variável chamada UNIT, que é um dado do programa.
(c) Na linha CLOSE(UNIT), deve-se notar que no comando CLOSE, no lugar do número do dispositivo que identifica o arquivo, é usado uma variável chamada UNIT, que é um dado do programa.
(d) Na linha VER = SYSTEM( TEXTO ), deve-se notar que no comando SYSTEM, no lugar de um texto específico, como era feito antes, por exemplo no programa14a.f90, é usado uma variável chamada TEXTO.
8) Executar o programa através de Build, Execute com:
Unidade de saída = 8
Nome do arquivo de saída = saida.txt
Figura 14.2 Resultado do programa14b.f90 para os dados do item 8.
Nome do arquivo de saída = saida14b.txt

Nome do arquivo de saída = saida
12) Analisar os resultados da execução 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 parâmetro “FORMATTED”, no comando OPEN, que aparece após a palavra-chave FORM, é a opção default. Ou seja, usando-o ou não, o resultado é o mesmo. Ele significa que o arquivo é do tipo texto, isto é, ao abri-lo, consegue-se ler o conteúdo, principalmente os números, escritos na base decimal.
14) Alterar a linha OPEN(UNIT, file = SAIDA, form = formatted )
para OPEN(UNIT, file = SAIDA, form = unformatted ) Alterar também 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 parâmetro “UNFORMATTED”, no comando OPEN, que aparece após a palavra-chave FORM, é usado para escrever resultados num arquivo do tipo binário. Isto é, ao abri-lo, não se consegue ler o conteúdo, de forma geral, principalmente os números, escritos na base binária. Para escrever em forma binária, no comando WRITE deve-se indicar apenas o número do dispositivo do arquivo, conforme exemplificado neste item 14. O formato binário é muito indicado para gravar grandes quantidades de resultados, pois precisa menos espaço 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
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho 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 parâmetro “REWIND”, no comando OPEN, que aparece após a palavra-chave POSITION é a opção default. Ou seja, usando-o ou não, o resultado é o mesmo. Ele é usado para fazer com que resultados sejam escritos a partir do início de um arquivo, seja o arquivo novo ou já existente.
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 parâmetro “APPEND”, no comando OPEN, que aparece após 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 serão escritos a partir do seu início.
12) Executar novamente os itens 7 e 8, acima.
13) Executar novamente o item 9, acima. O resultado da execução do programa14c.f90 deve ser o mostrado na Figura 14.4. Deve-se perceber que ele representa a soma das execuções 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 diferença 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 número 1 como o
dispositivo associado ao arquivo de dados chamado “dados.txt”.
INTEGER UNIT, VER
CHARACTER(50) SAIDA, TEXTO
Tabela 14.3 Programa14d.f90
VER = SYSTEM(Notepad dados.txt ) OPEN(1, file = dados.txt ) READ(1,*) UNIT

READ(1,*) SAIDA CLOSE(1)
Pi = DACOS(-1.0d0)
TEXTO = Notepad // SAIDA OPEN(UNIT, file = SAIDA ) WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO CLOSE(UNIT)
1/, 5X, Pi =, 1PE25.15,
1/, 5X, SAIDA = , A50,
1/, 5X, TEXTO = , A50 ) VER = SYSTEM( TEXTO )
END
(c) Nas linhas READ(1,*) UNIT e READ(1,*) SAIDA os dois dados são lidos, variáveis UNIT e SAIDA. Deve-se notar que são dois comandos READ, cada um sendo usado para ler uma única variável. Assim, após o programa ler o conteúdo da variável UNIT na primeira linha do arquivo “dados.txt”, tudo que estiver nesta linha após o valor de UNIT não é considerado pelo programa. Portanto, podem ser inseridos comentários nos arquivos de dados para ficar claramente definido ao que corresponde cada dado. O mesmo se aplica ao valor da variável SAIDA na segunda linha do arquivo “dados.txt”; o que está após este dado, na mesma linha, não é considerado pelo programa.
(d) Recomenda-se sempre fazer isso: um dado por linha e, em seguida, na mesma linha, um comentário para informar o que significa a variável. Além disso, nunca se deve usar formato para ler dados; este é o motivo do asterisco nos dois comandos READ. Os formatos devem ser usados apenas para escrever resultados.
(e) Todos os comentários já feitos nos capítulos anteriores e neste sobre o comando OPEN, para arquivos de resultados ou de saída, também valem para arquivos de entrada ou de dados.

8) Antes de executar um novo programa que use arquivo de dados, é necessário criar o arquivo de dados e inserir nele os respectivos dados. No caso do programa14d.f90, é necessário criar o arquivo “dados.txt” e inserir os dois dados que correspondem às variáveis UNIT e SAIDA. Para fazer isso, executar o seguinte:
(a) Start, Programs, Accessories, Notepad
(b) Dentro do espaço de edição 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 diretório do projeto. Em seguida, clicar sobre o botão “Save”. Finalmente, selecionar File, Exit.
Figura 14.5 Arquivo de dados “dados.txt” do programa14d.f90.
9) Executar o programa através de Build, Execute. O resultado deverá ser:
(a) A abertura do arquivo “dados.txt” com o programa Notepad. Se o arquivo não existir no diretório do projeto, ocorrerá um erro. Se o usuário quiser, poderá alterar o conteúdo das variáveis 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 conteúdo 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 através de Build, Execute com:
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-padrão, 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 número ou uma variável do tipo inteiro, por exemplo: a linha WRITE(9,11) UNIT, Pi do programa14a.f90, na qual o dispositivo é o número 9; e a linha WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO do programa14b.f90, na qual o dispositivo é a variável inteira UNIT. O dispositivo associado a um arquivo de resultados ou de dados também pode ser uma variável do tipo caracter.
(b) Na linha WRITE(TEXTO2,*) UNIT do programa14e.f90, define-se a variável TEXTO2, do tipo caracter, como o dispositivo no qual será escrito o conteúdo da variável UNIT, que é do tipo inteiro.
(c) Na linha WRITE(TEXTO3,*) Pi do programa14e.f90, define-se a variável TEXTO3, do tipo caracter, como o dispositivo no qual será escrito o conteúdo da variável Pi, que é do tipo real dupla.
(d) Na linha WRITE(TEXTO4,*) TEXTO // TEXTO3 do programa14e.f90, define-se a variável TEXTO4, do tipo caracter, como o dispositivo no qual será escrito o conteúdo da variável TEXTO concatenada com o conteúdo da variável TEXTO3, sendo ambas do tipo caracter.
(e) Na linha READ(TEXTO3,*) TEXTO5 do programa14e.f90, define-se a variável TEXTO3, do tipo caracter, como o dispositivo do qual será lido o conteúdo da variável TEXTO5, que é do tipo
caracter.
INTEGER UNIT, VER
Tabela 14.4 Programa14e.f90
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
TEXTO = Notepad // SAIDA WRITE(TEXTO2,*) UNIT WRITE(TEXTO3,*) Pi WRITE(TEXTO4,*) TEXTO // TEXTO3
READ(TEXTO3,*) TEXTO5
OPEN(UNIT, file = SAIDA )
WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO, TEXTO2, TEXTO3, TEXTO4, TEXTO5
CLOSE(UNIT)
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 ) VER = SYSTEM( TEXTO )
END

Analisar o resultado.
Figura 14.6 Resultado do programa14e.f90, com o item 8.
9) Executar novamente o programa através de Build, Execute com outros dados. Analisar o novo resultado.
14.6 EXERCÍCIOS
Exercício 14.1
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exercício 13.1 atendendo: (a) um arquivo para entrar os dados do programa;
(b) no início da execução do programa, abrir automaticamente o arquivo de dados com o aplicativo
Notepad;
(c) um arquivo para escrever os resultados do programa, com o nome do arquivo sendo definido pelo usuário;
(d) no final da execução do programa, abrir automaticamente o arquivo de resultados com o aplicativo
Notepad.
Exercício 14.2
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exercício 13.2 atendendo aos mesmos 4 itens do exercício 14.1.

Exercício 14.3
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o exercício 9.3 atendendo aos mesmos 4 itens do exercício 14.1.
Exercício 14.4
Seguindo o algoritmo do programa14d.f90, Tabela 14.3, refazer o programa da seção 12.4, Tabela 12.7, atendendo aos mesmos 4 itens do exercício 14.1.
Exercício 14.5
Implementar uma nova versão do programa14d.f90 para que: (a) o nome do arquivo de dados seja definido pelo usuário; e
(b) no início da execução do programa, o arquivo de dados seja aberto automaticamente com o aplicativo
Notepad.

Capítulo 15. Inicialização, tempo de CPU e DOS 178
Capítulo 15. INICIALIZAÇÃO, TEMPO DE CPU E DOS
• Inicializar variáveis e constantes junto com suas definições
• Versões DEBUG e RELEASE de um programa-executável
• Comandos do FORTRAN: PARAMETER, Formato AX
• Função do FORTRAN: TIMEF
• Comandos do DOS: MKDIR, COPY, ERASE, CD, RENAME, “arquivo”.BAT
(a) usar os novos comandos do FORTRAN: PARAMETER e formato AX (b) ao definir variáveis, inicializar seus valores; e
(c) escrever variáveis do tipo caracter com tamanho exato de seu conteúdo, usando o comando
FORMAT.
programa15a.f90
USE PORTLIB IMPLICIT NONE INTEGER VER, X
CHARACTER(50) SAIDA, TEXTO, COMENTARIO
INTEGER :: UNIT = 20
REAL*8, PARAMETER :: Pi = 3.14159E+00

VER = SYSTEM(Notepad DADOS.TXT ) OPEN(1, file = DADOS.TXT )
READ(1,*) COMENTARIO READ(1,*) SAIDA
CLOSE(1)
OPEN(UNIT, file = SAIDA ) 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( /, AX, = COMENTARIO ) CLOSE(UNIT)
TEXTO = Notepad // SAIDA VER = SYSTEM( TEXTO )
END
(a) Na linha INTEGER :: UNIT = 20 está sendo definida a variável UNIT como sendo do tipo inteiro e está sendo atribuído 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 variável Pi como sendo do tipo real de dupla precisão, está sendo atribuído o valor 3.14159 a ela. Ou seja, ela está sendo inicializada com o valor 3.14159. Além disso, ela está sendo definida como uma constante através do comando PARAMETER.
(c) Variáveis inicializadas podem ser alteradas dentro do programa.

(d) Variáveis inicializadas e definidas como constantes, com o comando PARAMETER, não podem ser alteradas dentro do programa. Isso gera erro de compilação.
(e) Diversas variáveis podem ser inicializadas numa mesma linha de programa. Basta separá-las por vírgula.
(f) Na linha WRITE(UNIT,12) TRIM(ADJUSTL(COMENTARIO)) escreve-se a variável COMENTARIO no arquivo definido por UNIT, com o formato definido pelo número 12. O uso das funções TRIM e ADJUSTL permite eliminar espaços em branco existentes no conteúdo da variável COMENTARIO, conforme visto no Capítulo 4.
(g) Na linha 12 FORMAT( /, AX, = COMENTARIO ) o identificador A, usado para escrever variáveis do tipo caracter, está sendo usado numa forma avançada, que permite escrever variáveis do tipo caracter com o tamanho exato de seu conteúdo. Isto é, sem espaços em branco, que ocorrem devido ao pré-dimensionamento que é necessário fazer ao se definir uma variável caracter, no caso CHARACTER(50) SAIDA, TEXTO, COMENTARIO. Na sintase AX, X é uma variável inteira, definida por X = LEN(TRIM(ADJUSTL(COMENTARIO))), cujo valor resulta da aplicação da função LEN.
8) Antes de executar o programa, é necessário criar o arquivo de dados e inserir nele os respectivos dados. No caso do programa15a.f90, é necessário criar o arquivo “DADOS.TXT” e inserir os dois dados que correspondem às variáveis 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 através de Build, Execute. O resultado deve ser o mostrado na Figura 15.2.
10) Executar novamente o programa com outros dados e analisar os novos resultados.

(a) usar uma nova função do FORTRAN: TIMEF; e
(b) mostrar a diferença, em termos de tempo de processamento, das versões DEBUG e RELEASE
de um programa-executável.
Figura 15.2 Resultado do programa15a.f90 para os dados da Figura 15.1.
programa15b.f90
USE PORTLIB IMPLICIT NONE
INTEGER VER, PASSOS, I CHARACTER(50) SAIDA, TEXTO
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)
TEXTO = Notepad // SAIDA

VER = SYSTEM( TEXTO )
END
(a) A função 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 função TIMEF mede o tempo de CPU em segundos.
(c) A função TIMEF é usada como na linha T1 = TIMEF() do programa, onde T1 deve ser uma variável do tipo real dupla.
(d) Dentro de um programa, a primeira chamada da função de TIMEF zera a contagem de tempo. As chamadas sucessivas, registram o tempo total transcorrido entre a zeragem e um ponto específico do programa. Desta forma, o tempo de processamento entre dois pontos é igual à diferença entre os tempos registrados nestes dois pontos.
(e) Como se poderá perceber nos exemplos, a função TIMEF não tem precisão muito elevada. A
repetição de um programa pode gerar diferenças de até ± 0.05 segundo.
(f) No FORTRAN, a medição do tempo de processamento de um programa também pode ser feita com as funções DTIME e ETIME, e a sub-rotina CPU_TIME.
(g) No FORTRAN 95, por default, uma variável do tipo inteiro não pode ter valor maior do que 231-
1, que corresponde a 2 147 483 647, ou seja, mais de 2 bilhões.
(h) Por default, quando se compila e se gera o executável de um programa, obtém-se a chamada versão DEBUG. Ela é útil para se encontrar erros de edição ou de uso dos comandos do FORTRAN, isto é, erros de sintaxe ou erros de compilação. Mas, em termos de tempo de processamento, a versão DEBUG é mais lenta (podendo chegar a 50%) do que a versão RELEASE. Além disso, a versão DEBUG geralmente resulta num programa-executável cujo arquivo precisa de mais memória em disco do que a versão RELEASE. Para definir o tipo de versão do programa, no menu principal do Fortran, deve-se executar “Build, Set Default Configuration...”, escolher a opção desejada e clicar no botão OK. Depois, deve-se compilar e gerar o executável do programa.
8) Antes de executar o programa, é necessário criar o arquivo de dados e inserir nele os respectivos dados. No caso do programa15b.f90, é necessário criar o arquivo “DADOS.TXT” e inserir os dois

dados que correspondem às variáveis PASSOS e SAIDA. Usar, por exemplo, os dados mostrados na Figura 15.3, onde PASSOS é igual a 100 milhões.
9) Executar o programa através de Build, Execute. O resultado é mostrado na Figura 15.4. Os tempos de processamento se referem à execução 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 diferença entre eles de 0.01 s. A
cada execução do programa, tanto os valores do tempo de CPU quanto suas diferenças 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, versão DEBUG.
10) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por exemplo, PASSOS = 10 milhões, 1 milhão e 1 bilhão.
11) Verificar se dentro do diretório do projeto existe um subdiretório chamado DEBUG. Se não, isto é, se o diretório existente for chamado RELEASE, onde se lê DEBUG, nos itens 12 a 14, abaixo, deve-se ler RELEASE e vice-versa.
12) Mudar a versão do programa para RELEASE. Para fazer isso, executar Build, Set Default
Configuration..., escolher a opção RELEASE, clicar no botão OK. Depois, executar Build,

Compile para compilar novamente o programa. Gerar o novo programa-executável fazendo Build, Build.
13) Verificar se dentro do diretório do projeto também existe um subdiretório chamado
RELEASE.
14) Executar o programa através 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 diferença entre eles de 0.099 s. Comparando-se os tempos de processamento, verifica-se que a versão DEBUG é mais lenta cerca de 43% do que a versão RELEASE.
Figura 15.5 Resultado do programa15b.f90 para os dados da Figura 15.3, versão RELEASE.
15) Executar novamente o programa com outros dados e analisar os novos resultados. Utilizar, por exemplo, PASSOS = 10 milhões, 1 milhão e 1 bilhão.
1) Objetivo do programa: utilizar comandos do DOS durante a execução do programa.
programa15c.f90
4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho mostrado na Tabela 15.3, que é o programa15c.f90.

USE PORTLIB IMPLICIT NONE INTEGER DOS
Tabela 15.3 Programa15c.f90
CHARACTER(50) SAIDA, COMENTARIO INTEGER :: UNIT = 20
DOS = SYSTEM(Notepad DADOS.TXT ) OPEN(1, file = DADOS.TXT )
READ(1,*) COMENTARIO READ(1,*) SAIDA
CLOSE(1)
OPEN(UNIT, file = SAIDA ) WRITE(UNIT,11) COMENTARIO, SAIDA
11 FORMAT(1/, COMENTARIO = , A50,
2/, SAIDA = , A50 ) CLOSE(UNIT)
! edição de comandos no arquivo EXECUTA.BAT OPEN(UNIT, file = EXECUTA.BAT ) WRITE(UNIT,*) MKDIR C:TEMPFORTRAN
WRITE(UNIT,*) COPY // TRIM(SAIDA) // C:TEMPFORTRAN // TRIM(SAIDA) WRITE(UNIT,*) ERASE // TRIM(SAIDA)
WRITE(UNIT,*) CD C:TEMPFORTRAN
WRITE(UNIT,*) RENAME // TRIM(SAIDA) // NOVO.TXT CLOSE (UNIT)
! fim

DOS = SYSTEM ( EXECUTA.BAT )
DOS = SYSTEM( Notepad C:TEMPFORTRANNOVO.TXT ) END
(a) O comando do DOS chamado MKDIR é usado para criar um novo diretório. Ele é usado na forma:
MKDIR DIRETORIO
onde DIRETORIO é o nome do diretório a ser criado, incluindo o caminho completo desde a raiz do HD (hard disk) ou disquete. Se o caminho não é especificado, o diretório é criado dentro do diretório 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 diretório de cada arquivo, incluindo o caminho completo desde a raiz do HD (hard disk) ou disquete. Se os diretórios e caminhos não são especificados, ARQ1 deve existir no diretório no qual o comando é executado, e ARQ2 é gerado no mesmo diretório.
(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 diretório, incluindo o caminho completo desde a raiz do HD (hard disk) ou disquete. Se o diretório e caminho não são especificados, ARQ deve existir no diretório no qual o comando é executado.
(d) O comando do DOS chamado CD é usado para mudar a execução do programa para outro diretório. Ele é usado na forma:
CD DIRETORIO
onde DIRETORIO é o nome do diretório 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 diretório existe dentro do diretório 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 comentários para ARQ1 e ARQ2 feitos no item (b), acima.
(f) Ao se executar um arquivo com extensão “.BAT”, são executados todos os comandos DOS
dentro deste arquivo, linha por linha, de cima para baixo.
(g) Exemplos de aplicação dos comandos acima são apresentados no programa.
(h) Existem diversos outros comandos do DOS que podem ser empregados em função do objetivo desejado.
8) Antes de executar o programa, é necessário criar o arquivo de dados e inserir nele os respectivos dados. No caso do programa15c.f90, é necessário criar o arquivo “DADOS.TXT” e inserir os dois dados que correspondem às variáveis COMENTARIO e SAIDA. Usar, por exemplo, os dados mostrados na Figura 15.1.
(a) ocorre a abertura do arquivo “DADOS.TXT” (b) são lidos os dois dados
(c) cria-se o arquivo o arquivo de saída; escreve-se nele os dois dados lidos; e fecha-se este arquivo
(d) cria-se o arquivo “EXECUTA.BAT”; dentro dele, são escritas diversas instruções DOS; fecha-se este arquivo
(e) acessa-se o DOS para executar as instruções contidas no arquivo “EXECUTA.BAT”
(f) acessa-se o DOS para abrir, com o aplicativo Notepad, o arquivo “NOVO.TXT” localizado em
“C:TEMPFORTRAN”
10) Executar o programa através de Build, Execute. Analisar os resultados. A Figura 15.6 mostra o conteúdo do arquivo “EXECUTA.BAT”, gerado pelo programa15c.f90; verificar sua existência no diretório do projeto. A Figura 15.7 mostra os comandos que foram executados no DOS, como resultado da execução do arquivo “EXECUTA.BAT”. A Figura 15.8 mostra o conteúdo do arquivo de resultado do programa15c.f90; deve-se notar que seu nome é “NOVO.TXT” e que ele se localiza no diretório “C:TEMPFORTRAN”; verificar sua existência; além disso, o arquivo de saída foi eliminado do diretório do projeto.

Figura 15.6 Conteúdo do arquivo “EXECUTA.BAT” gerado pelo programa15c.f90.
Figura 15.7 Janela DOS resultante da execução do programa15c.f90.
Figura 15.8 Resultado da execução do programa15c.f90.
15.4 EXERCÍCIOS
Exercício 15.1
Adaptar o programa15a.f90, Tabela 15.1, para:

(a) inicializar uma variável do tipo caracter; (b) inicializar uma constante do tipo caracter;
(c) inicializar duas variáveis 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 conteúdos das variáveis e constantes dos itens (a) a (d).
Exercício 15.2
Adaptar o programa15b.f90, Tabela 15.2, para usar a função DTIME junto com TIMEF e comparar o tempo de CPU medido por cada função.
Exercício 15.3
Adaptar o programa15b.f90, Tabela 15.2, para que a variável SOMA seja do tipo inteiro. Notar a redução do tempo de CPU que ocorre.
Exercício 15.4
Adaptar o programa15b.f90, Tabela 15.2, para obter e escrever o tempo de CPU gasto entre a primeira e a última chamada da função TIMEF.
Exercício 15.5
Adaptar o programa15b.f90, Tabela 15.2, para incluir, antes da última chamada da função TIMEF, a instrução
READ(*,*) “Espere alguns segundos e pressione a tecla ENTER” Analisar o efeito desta instrução vazia no tempo de CPU.
Exercício 15.6
Adaptar o programa15c.f90, Tabela 15.3, visando generalizar o nome do diretório
“C:TEMPFORTRAN”
para qualquer nome que o usuário defina através do arquivo de dados.

Capítulo 16. Memória e sub-rotinas 2 191
Capítulo 16. MEMÓRIA E SUB-ROTINAS 2
• Estimar e verificar a memória computacional necessária para executar um programa
• Utilizar sub-rotina recursiva
• Controlar o fluxo de informações para dentro e para fora de sub-rotinas
• Comandos do FORTRAN: DEALLOCATE, RECURSIVE, INTENT(IN,OUT,INOUT)
(a) mostrar como estimar a memória computacional necessária para executar um programa; e
(b) usar um novo comando do FORTRAN: DEALLOCATE.
programa16a.f90
(a) O comando DEALLOCATE é usado para eliminar da memória do computador variáveis para as quais foi reservado memória por meio do comando ALLOCATE. Para usá-lo basta a palavra DEALLOCATE e, dentro de parênteses, as diversas variáveis separadas por vírgula. Não é necessário indicar novamente o tamanho das variáveis, pois isso já é conhecido do comando ALLOCATE. O comando DEALLOCATE só pode ser usado com variáveis cuja memória foi alocada com o comando ALLOCATE.
(b) Na linha DEALLOCATE ( A ) a variável A, do tipo inteiro, com N elementos, está sendo eliminada da memória do computador.
(c) A estimativa da memória necessária para executar um programa pode ser obtida através da

seguinte equação:

Memória(kB) =
4*(N
int eiro
+ Nreal simples )
+ 8*N
1024
real dupla
+ 1*(L*N
caracter )
(16.1)
onde Ninteiro, Nreal simples e Nreal dupla representam o número total de elementos de conjuntos ou matrizes de variáveis do tipo inteiro, real simples e real dupla, respectivamente; Ncaracter representa o número total de elementos de variáveis do tipo caracter que tem comprimento ou número de caracteres igual a L. Dentro do último parênteses devem ser incluídos os produtos de outras variáveis do tipo caracter com outros comprimentos. Os valores 4, 8 e 1 representam o número de bytes que cada um dos tipos de variáveis ocupa de memória para um único elemento.
O valor 1024 é um fator usado para converter o número de bytes em kilobytes (kB).
USE PORTLIB IMPLICIT NONE INTEGER VER, N
INTEGER, ALLOCATABLE, DIMENSION(:) :: A REAL*8, ALLOCATABLE, DIMENSION(:) :: B CHARACTER(10), ALLOCATABLE, DIMENSION(:) :: C CHARACTER(50) SAIDA, TEXTO
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)
TEXTO = Notepad // SAIDA VER = SYSTEM( TEXTO ) 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

8) Antes de executar o programa, é necessário criar o arquivo de dados e inserir nele os respectivos dados. No caso do programa16a.f90, é necessário criar o arquivo “DADOS.TXT” e inserir os dois dados que correspondem às variáveis N e SAIDA. Usar, por exemplo, os dados mostrados na Figura 16.1.
9) Para ver a memória efetivamente usada pelo programa, deve-se abrir o gerenciador de tarefas ou
Task Manager, executando:
(a) clicar o botão do lado direito do mouse sobre a barra de tarefas do Windows (b) clicar o botão do lado esquerdo do mouse sobre a opção “Task Manager...” (c) clicar na opção “Processes” do menu principal do Task Manager
Figura 16.1 Exemplo de arquivo de dados para o programa16a.f90.
10) Executar o programa através de Build, Execute.
11) Conforme indica a janela DOS, ver no Task Manager qual a memória 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 memória 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 memória para variáveis do tipo conjunto, vetores ou matrizes com o comando ALLOCATE, a execução de um programa requer uma determinada memória. Ela é necessária para guardar as instruções do programa e os outros tipos de variáveis.
12) Continuar a executar o programa16a.exe, mantendo a janela do Task Manager aberta para ver a cada etapa do programa quanto de memória ele está usando. Deve-se perceber que:
(a) ao ser aberto o arquivo de dados com o aplicativo Notepad, a memória aumenta para 612 kB; (b) após a leitura dos dados e fechamento do aplicativo Notepad, a memória está em 648 kB;
(c) ao ser usado o comando ALLOCATE com as variáveis A, B e C, a memória sobe para 668 kB; isso significa que de fato não está ainda sendo usada a memória para estas variáveis, a não ser uma indicação das posições de memória que serão ocupadas;

(d) após a atribuição de valores às variáveis A, B e C a memória sobe para 22184 kB; agora, de fato, o espaço de memória aberto com o comando ALLOCATE para as variáveis A, B e C está sendo usado;
(e) após a eliminação da variável A, a memória cai para 18276 kB;
(f) após a eliminação das variáveis A e B, a memória cai para 10460 kB; (g) após a eliminação das variáveis A, B e C, a memória 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 não ocupa mais memória alguma, como se pode ver
no Task Manager.
Figura 16.2 Memória inicial usada pelo programa16a.exe.
13) A Figura 16.4 mostra a memória estimada com a Eq. (16.1) para as variáveis A, B e C do programa16a.exe. Na Tabela 16.2 tem-se a comparação entre a memória estimada (Figura 16.4) e a memória efetivamente usada, que foi obtida do Task Manager, nos subitens (d) a (g) do item 12, acima.
14) Executar novamente o programa com outros valores para N e analisar os novos resultados.

Figura 16.3 Janela DOS após a execução do programa16a.exe.
Figura 16.4 Memória estimada para executar o programa16a.exe.
Tabela 16.2 Comparação entre memória estimada e efetiva para as variáveis A, B e C do programa16a.f90.
Variável
Memória usada (kB)
Memória 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 aplicações pode ser necessário que uma sub-rotina tenha que chamar ela própria.
Neste caso, na definição da sub-rotina é necessário 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 capítulo 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) definições iniciais de variáveis e suas atribuições
(b) no programa principal, inicia-se um ciclo para a variável I
(c) dentro deste ciclo, chama-se a sub-rotina TESTE, do tipo recursiva
(d) dentro da sub-rotina TESTE, são executados uma condição e alguns comandos, e chama-se a própria sub-rotina TESTE
(e) a sub-rotina TESTE continua a chamar ela própria até que seja satisfeita a condição
(f) em seguida, começa-se a retornar para fora da sub-rotina TESTE tantas vezes quanto ela foi chamada por ela própria, desde a última chamada até a primeira
(g) finalmente, retorna-se ao programa principal e encerra-se a sua execução
9) Executar o programa através 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 informações para dentro e para fora de sub-rotinas; e
(b) usar um novo comando do FORTRAN: INTENT com parâmetros IN, OUT e INOUT.

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 variáveis usadas no programa-principal e em todas as sub-rotinas do mesmo programa. Caso contrário, ocorrerá erro de compilação.
(b) Todas as variáveis definidas no programa-principal são válidas dentro das sub-rotinas do programa. Elas são chamadas de variáveis globais. Por exemplo, as variáveis A, B, C, D, E e F do programa16c.f90, definidas na linha INTEGER A, B, C, D, E, F, são variáveis globais do programa.
(c) As variáveis definidas dentro de uma sub-rotina são válidas somente dentro da própria sub- rotina. Elas são chamadas de variáveis locais. Seus valores ou conteúdos podem ser passados para outras sub-rotinas ou para o programa-principal através dos argumentos da sub-rotina. Por exemplo, as variáveis R e S do programa16c.f90, definidas na linha INTEGER R, S, são variáveis locais da sub-rotina TESTE.
(d) Todas as atribuições feitas a variáveis globais são reconhecidas dentro das sub-rotinas do programa.
(e) Todas as atribuições feitas a variáveis locais não são reconhecidas fora das sub-rotinas do programa.

PROGRAM CAPITULO_16C IMPLICIT NONE
INTEGER A, B, C, D, E, F
Tabela 16.4 Programa16c.f90
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 informações para dentro e para fora das sub-rotinas. Ele é usado quando se define cada variável empregada como argumento das sub- rotinas.
(g) O comando INTENT é utilizado com três parâmetros (IN, OUT e INOUT) que definem o sentido do fluxo da informação.
(h) O comando INTENT(IN) permite que a variável apenas receba informação de fora da sub-rotina.
Um exemplo é dado no programa16c.f90 na linha INTEGER, INTENT(IN) :: X, Y. As variáveis X e Y só podem receber informação de fora da sub-rotina TESTE. A tentativa de atribuir valor a elas dentro da sub-rotina gerará erro de compilação. Mas elas podem ser empregadas em expressões dentro da sub-rotina, como na linha Z = X + Y
(i) O comando INTENT(OUT) permite que a variável apenas envie informação para fora da sub- rotina. Um exemplo é dado no programa16c.f90 na linha INTEGER, INTENT(OUT) :: Z. A variável Z só pode enviar informação para fora da sub-rotina TESTE.

(j) O comando INTENT(INOUT) permite que a variável receba informação de fora da sub-rotina e também que ela envie informação para fora da sub-rotina. Um exemplo é dado no programa16c.f90 na linha INTEGER, INTENT(INOUT) :: T. A variável T pode receber e enviar informação na sub-rotina TESTE.
(k) Quando não se usa o comando INTENT numa variável 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 variável R, uma vez que a variável S não é argumento da sub-rotina TESTE.
(l) Recomenda-se o uso do comando INTENT. Ele evita erros de lógica, principalmente em programas grandes com muitas variáveis.
(m) Recomenda-se usar como variáveis globais apenas aquelas que são efetivamente usadas no programa-principal. Variáveis utilizadas em sub-rotinas devem ser definidas apenas nas próprias sub-rotinas.
8) Executar o programa através de Build, Execute, usando por exemplo A = 1 e B = 2. O resultado é mostrado na Figura 16.6. Analisar os resultados considerando os comentários 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 EXERCÍCIOS
Exercício 16.1
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos elementos são do tipo inteiro, com X1 por Y1 elementos.
Exercício 16.2
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos elementos são do tipo real dupla, com X2 por Y2 elementos.
Exercício 16.3
Estimar e verificar a memória computacional necessária para usar uma matriz bidimensional, cujos elementos são do tipo caracter, cada um com 100 caracteres, com X3 por Y3 elementos.
Exercício 16.4
Juntar as matrizes dos exercícios 16.1 a 16.3 num único programa para estimar e verificar a memória computacional total que é necessária para as três matrizes.
Exercício 16.5
Adaptar a sub-rotina FATORIAL, da Tabela 12.4, do capítulo 12, para ser uma sub-rotina do tipo recursiva. E implementar um programa-principal para ela.
Exercício 16.6
Adaptar o programa12d, Tabela 12.7, do capítulo 12, para:
(a) usar onde pertinente o comando INTENT com IN, OUT e INOUT; (b) usar o comando IMPLICIT NONE no programa-principal;
(c) ter uma sub-rotina com a finalidade de ler os dados de um arquivo;
(d) ter uma sub-rotina com a finalidade de escrever os resultados num arquivo; e
(e) ter uma sub-rotina com a finalidade de abrir os arquivos de dados e de saída com o aplicativo
Notepad.

Exercício 16.7
Adaptar o programa16c.f90, Tabela 16.4, deste capítulo, para ter como argumentos da sub-rotina TESTE variáveis do tipo real dupla, caracteres e um conjunto unidimensional (vetor) com elementos do tipo inteiro.

Capítulo 17. Módulos 206
Capítulo 17. MÓDULOS
• Utilizar módulos
• Comandos do FORTRAN: MODULE, END MODULE, PRIVATE, PUBLIC
(a) exemplificar o uso e as características básicas de módulos em FORTRAN; e
(b) usar dois novos comandos do FORTRAN: MODULE, END MODULE.
3) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte dados.f90
5) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte saida.f90
principal.f90
(a) Um módulo é praticamente igual a um programa-principal. A maior diferença é que num módulo não se pode ter comandos executáveis antes do comando CONTAINS, ao contrário do que ocorre num programa-principal.
(b) A definição de módulo em FORTRAN deve seguir a sintaxe mostrada na Tabela 17.4. O nome do módulo segue as regras válidas para variáveis em FORTRAN, não podendo ser igual a nenhum outro nome de módulo, variável ou sub-rotina do programa. No caso de não haver sub-

rotinas num módulo, o comando CONTAINS não deve ser usado; um exemplo disso é um módulo usado para definir as variáveis globais do programa.
(c) O uso de módulos facilita muito a estruturação de programas de grande porte próprios.
(d) Para não haver problemas com definição de variáveis, deve-se usar o comando IMPLICIT NONE dentro de cada módulo.
(e) Um módulo pode ser usado dentro de uma sub-rotina, de outro módulo ou dentro de um programa-principal através do comando USE seguido do nome do módulo.
(f) Dentro de um módulo, as variáveis definidas antes do comando CONTAINS são reconhecidas por todas as sub-rotinas do módulo, ou seja, elas são variáveis globais do módulo onde estão definidas.
(g) Um programa-fonte pode conter um ou vários módulos em seqüência.
(h) A compilação dos programas-fonte que contêm módulos deve ser feita na seguinte ordem: (1) os módulos que não dependem de outros; (2) os módulos 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.
MODULE DADOS IMPLICIT NONE REAL*8 I, J
CONTAINS
SUBROUTINE LE_DADOS
Tabela 17.1 Programa-fonte dados.f90
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 através de Build, Execute. Usar, por exemplo, os valores 1 e 2 para as variáveis I e J, respectivamente. Neste caso, os resultados da execução 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 três programas-fonte e os comentários do item 9, acima.
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
Tabela 17.2 Programa-fonte saida.f90
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
PROGRAM PROGRAMA17A USE SAIDA
IMPLICIT NONE CALL LE_DADOS CALL CALCULOS
CALL RESULTADOS
Tabela 17.3 Programa-fonte principal.f90
WRITE(*,*) I, J, K = , I, J, K
END PROGRAM PROGRAMA17A
MODULE NOME
Tabela 17.4 Sintaxe de um módulo em FORTRAN.
comandos USE e EXTERNAL
definições de variáveis
CONTAINS
sub-rotinas
END MODULE NOME
1) Objetivo do programa: entender o uso de módulos num programa composto por quatro módulos.

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 após a execução do programa17a.exe.
4) Clicar com o botão do lado direito do mouse sobre o arquivo calculos.f90
5) Escolher a opção Save Target As
6) Na opção Save in, localizar o diretório do projeto
7) Clicar no botão Save
8) Repetir os itens 4 a 7, acima, para os arquivos dados.f90, dados.txt, modulo.f90, resultados.f90 e variaveis.f90
(a) Ele é composto por quatro módulos, sendo cada um editado num programa-fonte.
(b) O módulo VARIAVEIS é usado para definir todas as variáveis usadas no programa.
(c) O programa-principal incorpora apenas o módulo RESULTADOS. Mas este, tem incorporado dentro de si o módulo CALCULOS, que incorpora o módulo DADOS, que finalmente incorpora

o módulo VARIAVEIS. Assim, todos os módulos estão também implicitamente inseridos dentro do programa-principal. A ordem de compilação deve ser a inversa desta seqüência.
10) Estudar os quatro módulos e o programa-principal considerando os comentários do item 9 desta seção 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 através 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 variáveis públicas e privadas em módulos;
(b) usar dois novos comandos do FORTRAN: PUBLIC e PRIVATE; e
(c) entender o uso de módulos com variáveis públicas e privadas num programa-exemplo.
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17c/
4) Clicar com o botão do lado direito do mouse sobre o arquivo base.f90
5) Escolher a opção Save Target As
6) Na opção Save in, localizar o diretório do projeto
7) Clicar no botão Save
8) Repetir os itens 4 a 7, acima, para os arquivos base2.f90 e main.f90
(a) Dois novos comandos do FORTRAN, associados ao uso de módulos, são usados neste programa: PUBLIC e PRIVATE.
(b) O comando PRIVATE é empregado para definir uma variável como privativa do módulo no qual ela é definida. Ou seja, ela só é reconhecida pelas sub-rotinas definidas dentro do próprio módulo. Ela não é reconhecida como variável dentro de outros módulos ou do programa- principal que utilizem o módulo no qual ela está definida. Um exemplo é dado na linha integer,private :: N do módulo PRIMEIRO: a variável N só é reconhecida como tal dentro do módulo PRIMEIRO; o mesmo ocorre com a variável R. As variáveis R e N do módulo SEGUNDO são diferentes das variáveis R e N do módulo PRIMEIRO.
(c) O comando PUBLIC é empregado para definir uma variável como global. Isto é, ela é reconhecida pelas sub-rotinas definidas dentro do próprio módulo, e também dentro de outros módulos ou do programa-principal que utilizem o módulo no qual ela está definida. Um exemplo é dado na linha integer,public :: K do módulo PRIMEIRO: a variável K é reconhecida como tal dentro do módulos PRIMEIRO e SEGUNDO, e do programa-principal.
(d) Todas as variáveis definidas num módulo antes do comando CONTAINS são assumidas como PUBLIC, a menos que sejam explicitamente definidas como PRIVATE. Um exemplo é dado na linha integer :: L do módulo PRIMEIRO: a variável L é entendida como PUBLIC.

(e) Mas todas as variáveis definidas numa sub-rotina são assumidas como PRIVATE.
10) Estudar os dois módulos e o programa-principal considerando os comentários do item 9 desta seção e da seção 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 através 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 EXERCÍCIOS
Exercício 17.1
(a) Transformar o programa12d.f90 num módulo. (b) Fazer o mesmo para o programa16c.f90.
(c) Criar um programa-principal para executar as rotinas destes dois módulos.

Capítulo 18. Solução de séries e raízes de equações 212
Capítulo 18. SOLUÇÃO DE SÉRIES E RAÍZES DE EQUAÇÕES
• Calcular o resultado de séries infinitas
• Aplicar os métodos de iteração linear, bisseção e Newton para determinar raízes de equações
• Revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot
• Alterar dinamicamente arquivo de comandos do programa de gráficos Wgnuplot e usar novos
comandos
(a) exemplificar o cálculo do resultado de séries infinitas;
(b) revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot; e
(c) alterar dinamicamente arquivo de comandos do programa de gráficos Wgnuplot e usar novos comandos.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome projeto_18
3) Acessar o site ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_18
4) Clicar com o botão do lado direito do mouse sobre o arquivo programa18a.f90
5) Escolher a opção Copiar para pasta... (Save Target As)
6) Localizar a pasta do projeto
7) Clicar no botão OK
8) Repetir os itens 3 a 7, acima, para os arquivos dados18a.txt, comandos18a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte
programa18a.f90, mostrado na Tabela 18.1.
10) Estudar o programa-principal considerando os comentários do item 11, abaixo.
(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.

(c) A sub-rotina SERIE_1 é usada para calcular a soma dos N termos da seguinte série geométrica
infinita:
(18.1)
(d) A sub-rotina SERIE_2 é usada para calcular o valor de π através da soma dos N termos da
seguinte série infinita:
(e) A sub-rotina SERIE_3 é usada para calcular o valor do número e através da soma dos N termos
da seguinte série infinita, onde cada termo envolve a sub-rotina FATORIAL:
(f) As sub-rotinas das três séries também calculam o erro para a solução exata e escrevem no arquivo saida18a.txt o número e valor de cada termo da série, a soma dos termos e o erro.
(g) A sub-rotina GRAFICO: abre o arquivo comandos18a.gnu; pula as sete primeiras linhas deste arquivo; na oitava linha, escreve um comentário para representar o título do gráfico de acordo com a série escolhida para cálculo; na nona linha, escreve outro comentário, que é o comando replot do Wgnuplot; finalmente, esta sub-rotina executa o programa Wgnuplot para fazer o gráfico semilog do erro do cálculo da série escolhida, em função do número de termos N usado.
(h) O programa-principal: chama a sub-rotina DADOS; cria o arquivo saida18a.txt; escreve nele um comentário na primeira linha para indicar o significado de cada coluna de resultados; o símbolo
# é usado para informar ao Wgnuplot que a linha é apenas um comentário, e não dados para o
gráfico; dependendo do tipo de série escolhida pelo usuário é chamada a sub-rotina adequada; o
Notepad abre o arquivo de saída; e, é chamada a sub-rotina para fazer o gráfico do erro.
14) Executar o programa através 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 série geométrica 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
! calcula soma da série 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
! calcula soma da série 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 'série geométrica' case ( 2 )
write(9,*) set title 'série de pi' case ( 3 )
write(9,*) set title 'série 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. Gráfico com resultados do programa18a.f90 para os dados da Fig. 18.1.

1) Objetivo do programa: para uma equação quadrática específica, aplicar os métodos de iteração linear, bisseção e Newton para determinar suas raízes.
Fortran:
a) Clicar sobre o nome do programa-fonte.
c) Clicar dentro do campo de edição de programa-fonte.
d) File, Close.
4) Clicar com o botão 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-padrão, inserir no projeto o programa-fonte programa18b.f90, mostrado na Tabela 18.2.
(a) O programa18b.f90 é composto pelo programa-principal e cinco sub-rotinas.
(b) Para as sub-rotinas DADOS e GRAFICO e o programa-principal valem os mesmos comentários da seção anterior, exceto que os arquivos envolvidos são agora dados18b.txt, comandos18b.gnu e saida18b.txt.
(c) As sub-rotinas LINEAR, BISSECAO e NEWTON resolvem a equação
x2 − 5x
+ 6 = 0
(18.4)
através dos métodos de iteração linear, bisseção e Newton para determinar suas raízes. Detalhes sobre estes métodos podem ser encontrados na maioria dos livros de cálculo numérico.
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.
20)No Fortran, para fechar o projeto atual, executar File, Close Workspace.
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 equação quadrática com o método da iteração linear
do i = 1, n
x = ( ( x ** 2 ) + 6 ) / 5 erro = dabs(exato - x) write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
end subroutine linear
!------------------------------------------------- subroutine bissecao
! calcula raiz de uma equação quadrática com o método da bisseção

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
write(6,10) i, x, erro
10 format( i8, 2(1pe30.15e3) )
end do
end subroutine bissecao
!------------------------------------------------- subroutine newton
! calcula raiz de uma equação quadrática com o método de Newton real*8 f, fl
do i = 1, n
f = x**2 - 5*x + 6 fl = 2*x - 5
x = x - f / fl
write(6,10) i, x, erro
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 'método da iteração linear' case ( 2 )
write(9,*) set title 'método da bisseção' case ( 3 )
write(9,*) set title 'método de Newton' end select
ver = system (Wgnuplot comandos18b.gnu)
!------------------------------------------------- end program raizes
Figura 18.4 Arquivo de dados do programa18b.f90.

18.3 EXERCÍCIOS
Exercício 18.1
Adaptar o programa18a.f90 para incluir as seguintes opções de séries:
Figura 18.5 Parte do arquivo de resultados do programa18b.f90 para os dados da Fig. 18.4.
Exercício 18.2
Adaptar o programa18a.f90 para usar precisão simples em todos os cálculos com números reais. Comparar os resultados com a versão original do programa18a.f90 na qual usa-se precisão dupla.

Exercício 18.3
Adaptar o programa18b.f90 para usar precisão simples em todos os cálculos com números reais. Comparar os resultados com a versão original do programa18b.f90 na qual usa-se precisão dupla.
Exercício 18.4
Adaptar o programa18b.f90 para resolver a seguinte equação:
x2 − x
− 6 = 0
(18.9)
Figura 18.6 Gráfico com resultados do programa18b.f90 para os dados da Fig. 18.4.

Capítulo 19. Derivadas e integrais numéricas 226
Capítulo 19. DERIVADAS E INTEGRAIS NUMÉRICAS
• Calcular derivadas numéricas com quatro tipos de aproximações numéricas do método de diferenças finitas: UDS, DDS, CDS-2 e CDS-4.
• Calcular integrais numéricas com três tipos de aproximações numéricas: regras do retângulo, trapézio
e Simpson.
1) Objetivo do programa: calcular derivadas numéricas com quatro tipos de aproximações numéricas do método de diferenças finitas: UDS, DDS, CDS-2 e CDS-4.
2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome projeto_19
8) Repetir os itens 3 a 7, acima, para os arquivos dados19a.txt, comandos19a.gnu, Wgnuplot.exe
9) No Fortran, seguindo o procedimento-padrão, inserir no projeto o programa-fonte
programa19a.f90, mostrado na Tabela 19.1.
(a) O programa19a.f90 é composto pelo programa-principal e quatro sub-rotinas.
(b) A sub-rotina DADOS é usada para ler os dados do programa do arquivo dados19a.txt.
(c) A sub-rotina EXPONENCIAL é usada para calcular a derivada numérica da função f = ex com quatro tipos de aproximações numéricas do método de diferenças finitas:

onde h = Δx, intervalo em x usado para aproximar cada derivada. Esta sub-rotina também calcula
o erro de cada uma das quatro aproximações numéricas em relação à solução analítica da derivada que é ex.
(d) A sub-rotina POTENCIA é usada para calcular a derivada numérica da função f = x5 com os
quatro tipos de aproximações numéricas das Eqs. (19.1) a (19.4). Esta sub-rotina também calcula o erro de cada uma das quatro aproximações numéricas em relação à solução analítica da derivada que é 5x4.
(e) A sub-rotina GRAFICO abre o arquivo comandos19a.gnu e desce as primeiras doze linhas deste arquivo. Na linha seguinte, escreve um comentário para representar o título do gráfico de acordo com a função escolhida para calcular a derivada. E na linha seguinte, escreve outro comentário, que é o comando replot do Wgnuplot. Finalmente, esta sub-rotina executa o programa Wgnuplot para fazer o gráfico log-log do erro do cálculo da derivada da função escolhida, para cada uma das quatro aproximações numéricas, em função do número de refinos de h definido nos dados do programa.
(f) O programa-principal: (1) define suas variáveis globais; (2) chama a sub-rotina DADOS; (3) cria o arquivo saida19a.txt; (4) escreve nele um comentário na primeira linha para indicar o
significado de cada coluna de resultados (o símbolo # é usado para informar ao Wgnuplot que a
linha é apenas um comentário, e não dados para o gráfico); (5) dependendo do tipo de função escolhida pelo usuário, é chamada a sub-rotina adequada; (6) o Notepad abre o arquivo de saída; e, (7) é chamada a sub-rotina para fazer o gráfico dos erros com os comandos mostrados na Figura 19.1.

program derivadas use portlib implicit none
integer :: i ! número da aproximação de cada delta integer :: L ! número de refinos de hmax
integer :: ver ! auxílio de System
integer :: tipo_funcao ! tipo de função a derivar
real*8 :: hmax ! maior delta
real*8 :: r ! razão de refino dos deltas
real*8 :: X ! coordenada para calcular a derivada real*8 :: exato ! solução analítica 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
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
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 aproximações UDS e DDS apresentam quase os mesmos valores de erro. Conforme previsto pela teoria, as aproximações CDS-2 e CDS-4 apresentam os menores valores de erro para um mesmo h. Teoricamente, o erro de cada aproximação deveria sempre se reduzir com a redução de h, e deveria

atingir o valor nulo para h = 0. Porém, na prática, os erros de arredondamento impõem um limite mínimo ao erro de cada aproximação, 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 função = 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 numéricas com três tipos de aproximações numéricas:
regras do retângulo, trapézio e Simpson.
Fortran:
a) Clicar sobre o nome do programa-fonte.
c) Clicar dentro do campo de edição de programa-fonte. d) File, Close.
4) Clicar com o botão 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-padrão, inserir no projeto o programa-fonte programa19b.f90, mostrado na Tabela 19.2.

program integrais use portlib implicit none
integer :: i ! número do refino dos elementos de integração integer :: j ! número do elemento de integração
integer :: Nmin ! número mínimo de elementos de integração integer :: L ! número de refinos de elementos de integração integer :: r ! razão de aumento de elementos de integração integer :: ver ! auxílio de System
integer :: tipo_funcao ! tipo de função a derivar
real*8 :: h ! tamanho dos elementos de integração real*8 :: exato ! solução analítica da derivada
call dados ! lê os dados do programa open(6,file=saida19b.txt) !
write(6,10)
10 format(#, t5,h, t20,E(retângulo), t35,E(trapézio), 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
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
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 numérica da função f = ex com três tipos de aproximações numéricas:

onde xk = h*k. Esta sub-rotina também calcula o erro de cada uma das três aproximações numéricas em relação à solução analítica da integral que é e-1.
(d) A sub-rotina POTENCIA é usada para calcular a integral numérica da função f = x5 com os três
tipos de aproximações numéricas das Eqs. (19.5) a (19.7). Esta sub-rotina também calcula o erro de cada uma das três aproximações numéricas em relação à solução analítica 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 comentário para representar o título do gráfico de acordo com a função escolhida para calcular a integral. E na linha seguinte, escreve outro comentário, que é o comando replot do Wgnuplot. Finalmente, esta sub-rotina executa o programa Wgnuplot para fazer o gráfico log-log do erro do cálculo da integral da função escolhida, para cada uma das três aproximações numéricas, em função do número (N) de intervalos (h) de integração definido com os dados do programa.
(f) O programa-principal: (1) define suas variáveis globais; (2) chama a sub-rotina DADOS; (3) cria o arquivo saida19b.txt; (4) escreve nele um comentário na primeira linha para indicar o
significado de cada coluna de resultados (o símbolo # é usado para informar ao Wgnuplot que a
linha é apenas um comentário, e não dados para o gráfico); (5) dependendo do tipo de função escolhida pelo usuário, é chamada a sub-rotina adequada; (6) o Notepad abre o arquivo de saída; e, (7) é chamada a sub-rotina para fazer o gráfico dos erros com os comandos mostrados na Figura
19.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 aproximações das regras do retângulo e trapézio 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 aproximação deveria sempre se reduzir com a redução de h, e deveria atingir o valor nulo para h = 0. Porém, na prática, os erros de arredondamento impõem um limite mínimo ao erro de cada aproximação, como mostrado na Figura 19.8 para a regra de Simpson.
16) Executar novamente o programa usando tipo de função = 1 e analisar os novos resultados.
18)No Fortran, para fechar o projeto atual, executar File, Close Workspace.
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 EXERCÍCIOS Exercício 19.1
Acrescentar uma sub-rotina no programa19a.f90 para calcular a derivada de f = 3ex. Incluir a nova opção de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos quatro tipos de aproximações e respectivo gráfico.

Exercício 19.2
Acrescentar uma sub-rotina no programa19a.f90 para calcular a derivada de f = x4. Incluir a nova opção de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos quatro tipos de aproximações e respectivo gráfico.
Figura 19.8. Gráfico com resultados do programa19b.f90 para os dados da Fig. 19.6.
Exercício 19.3
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = 3ex. Incluir a nova opção de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos três tipos de aproximações e respectivo gráfico.
Exercício 19.4
Acrescentar uma sub-rotina no programa19b.f90 para calcular a integral de f = x4. Incluir a nova opção de função no arquivo de dados e no programa. Apresentar arquivo com o erro dos três tipos de aproximações e respectivo gráfico.

Capítulo 20. Solução de sistemas de equações 243
Capítulo 20. SOLUÇÃO DE SISTEMAS DE EQUAÇÕES
• Aplicar, num único programa, diversos recursos e comandos do FORTRAN vistos nos capítulos anteriores.
• Resolver sistemas de equações lineares com métodos diretos e iterativos.
1) Objetivo do programa: resolver um problema de condução de calor unidimensional permanente através de simulação numérica com o método de diferenças finitas. A solução dos sistemas de equações lineares do problema é obtida com métodos diretos e iterativos.
2) No Fortran, seguindo o procedimento-padrão, 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-padrão, inserir no projeto o programa-fonte variaveis.f90, mostrado na Tabela 20.1.
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 módulos, editados em seis programas-fonte diferentes.
(b) No módulo VARIAVEIS, contido no programa-fonte variaveis.f90, são definidas as variáveis

globais do programa. Este módulo não contém nenhuma sub-rotina.
(c) O módulo SOLVERS_1D, contido no programa-fonte solvers_1D.f90, é dedicado à solução de
sistemas de equações lineares do tipo
AT = B
(20.1)
originados de problemas unidimensionais. A é a matriz de coeficientes, T é o vetor incógnita e B é o vetor dos termos independentes. A dimensão de A é NxN, e de T e B, Nx1, onde N é o número de incógnitas (T) do problema. Este módulo contém quatro sub-rotinas. Três delas são métodos para resolver sistemas de equações. O método de eliminação de Gauss resolve uma matriz A do tipo cheia de forma direta. O método de Gauss-Seidel resolve uma matriz A do tipo cheia mas de forma iterativa. Neste programa-exemplo, os métodos eliminação de Gauss e Gauss-Seidel estão adaptados para resolver uma matriz A do tipo tridiagonal, isto é, apenas três diagonais da matriz A têm valores não-nulos. Finalmente o método TDMA (Tri-Diagonal Matrix Algorithm) resolve uma matriz A do tipo tridiagonal de forma direta. Além disso, existe uma
rotina que calcula a norma l1 média do resíduo das equações do sistema, definido por
R = B − AT
(20.2)
O valor da norma é usado para comparar com uma tolerância especificada pelo usuário visando interromper o processo iterativo do método de Gauss-Seidel.
(d) O módulo DADOS, contido no programa-fonte dados.f90, tem duas sub-rotinas. Uma é usada para ler os dados do programa, do arquivo programa20a.ent. A outra é usada para escrever os dados lidos num arquivo de saída de nome genérico.
(e) O módulo COEFICIENTES, contido no programa-fonte coeficientes.f90, tem duas sub-rotinas.
Uma é usada para definir os valores dos coeficientes da matriz A e do termo independente B do sistema de equações das N variáveis T. São definidos os valores dos coeficientes apenas em três diagonais da matriz A. Isso ocorre porque estes coeficientes são originados da discretização de uma equação diferencial que modela a condução de calor unidimensional em regime permanente; e a aproximação usada, do método de diferenças finitas, é a diferença central de 2ª ordem, CDS-2, vista no capítulo 19. O valor de B depende da definição do usuário no arquivo de dados, gerando valores nulos ou não-nulos. A outra sub-rotina é usada para escrever os valores dos coeficientes e do termo independente num arquivo de saída de nome genérico.
(f) O módulo RESULTADOS, contido no programa-fonte resultados.f90, também tem duas sub- rotinas. A primeira é usada para: (1) chamar a sub-rotina de cálculo de coeficientes e termos independentes; (2) escrever os coeficientes; (3) resolver a Eq. (20.1) com um dos três métodos

disponíveis, de acordo com a escolha do usuário no arquivo de dados; (4) cronometrar o tempo de CPU; (5) chamar a segunda sub-rotina do módulo; e (6) escrever o tempo de CPU num arquivo de saída de nome genérico. A segunda sub-rotina deste módulo é usada para: (1) criar o arquivo T.dat; (2) escrever neste arquivo a solução analítica e numérica de T, e seu erro; (3) escrever um título no arquivo comandos20a.gnu; e (4) chamar o aplicativo Wgnuplot para fazer o gráfico de T com os comandos mostrados na Figura 20.1.
(g) O programa-principal: (1) apresenta comentários descrevendo um resumo das características do programa; (2) obtém a data e a hora do sistema operacional; (3) chama a sub-rotina de leitura dos dados do programa; (4) cria o arquivo de saída de nome genérico; (5) escreve nele o título da simulação, a data e hora; (6) faz a alocação de memória; (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 conteúdo do arquivo de saída.
(h) Os campos de coeficientes, T e gráfico são escritos com uma freqüência (w) definida pelo
usuário.
module variáveis use portlib implicit none
Tabela 20.1 Variaveis.f90
integer :: N ! número total de nós
integer :: i ! número do nó
! i = 1, nó no contorno esquerdo
! i = N, nó no contorno direito
! 2 = i = N-1, nós internos
integer :: matriz ! tipo de matriz: 1 = sem fonte; 2 = com fonte integer :: solver ! tipo de solver: 1 = Eliminação de Gauss (EG)
! 2 = Gauss-Seidel (GS)
! 3 = TDMA integer :: iteracao ! número de iterações para o GS integer :: w ! freqüência de escrita de resultados

real*8 :: Tol ! tolerância sobre resíduo para o GS
real*8 :: tcpu ! tempo de CPU em segundos integer :: ver ! auxílio do comando System real*8,dimension(:),allocatable :: T ! solução numérica 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 saída
character*50 :: title ! título do gráfico character*62 :: head ! título do gráfico + dia
character*12 :: dia ! data da simulação character*8 :: hora ! horário da simulação 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
module solvers_1D
Tabela 20.2 Solvers_1D.f90
! objetivo: resolver sistema linear de equações algébricas
! originado de problemas unidimensionais use variaveis

implicit none contains
!-------------------------------------------------
! Método direto eliminação de Gauss subroutine EG (N,ap,b,c,d,T)
implicit none
integer :: i ! número do nó integer :: ii, j
real*8 :: mji, S
integer,intent(in) :: N ! número de nós 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 ! incógnita 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

!-------------------------------------------------
! método iterativo de Gauss-Seidel subroutine GS (N,ite,tol,a,b,c,d,T)
implicit none
integer :: i ! número do nó integer :: it ! número da iteração integer :: ite ! número de iterações
integer,intent(in) :: N ! número de nós real*8, intent(in) :: Tol ! tolerância sobre R
real*8,intent(in), dimension(N) :: a ! 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 ! incógnita real*8 :: R ! norma l1 média dos resíduos
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, ' iterações',
/, 'para a tolerância de', 1pe10.2,
/, 'A norma l1 média dos resíduos é', 1pe10.2, /)
exit end if
end do
if ( R Tol ) then write(10,2) ite, Tol, R
2 format(//, 'O processo iterativo NÃO convergiu em', I8, ' iterações',
/, 'para a tolerância de', 1pe10.2,
/, 'A norma l1 média dos resíduos é', 1pe10.2, /)
end if
end subroutine GS
!-------------------------------------------------
! calcula a norma l1 média do resíduo das equações subroutine norma (N,a,b,c,d,T,R)
implicit none
integer :: i ! número do nó integer,intent(in) :: N ! número de nós real*8,intent(in), dimension(N) :: a ! 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 ! incógnita real*8,intent(inout) :: R ! norma l1 média dos resíduos 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
!-------------------------------------------------
! método direto Tri-Diagonal Matrix Algorithm (TDMA)
subroutine TDMA (N,a,b,c,d,T)
implicit none
integer :: i ! número do nó real*8 :: div ! variável auxiliar
integer,intent(in) :: N ! número de nós
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 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 ! incógnita 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
module dados
Tabela 20.3 Dados.f90
! 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',//,
acomp,' = caso',/,
i6,' = número de nós',/,
i6,' = tipo de matriz: 1 = fonte nulo; 2 = fonte não-nulo',/,
i6,' = tipo de solver: 1=El.Gauss; 2=GS; 3=TDMA',/,
i6,' = número de iterações para o GS',/,
1pe10.2,' = tolerância sobre o resíduo para o GS')
end subroutine mostra_dados
!------------------------------------------------- end module dados
module coeficientes
Tabela 20.4 Coeficientes.f90
! objetivo: calcular os coeficientes e termos fontes
! das equações 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 não-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
module resultados
Tabela 20.5 Resultados.f90
! objetivo: calcular solução numérica e
! apresentar gráficos dos resultados
!------------------------------------------------- use coeficientes
use solvers_1D implicit none contains
! ----------------------------------------------- subroutine solucao_numerica
! cálculo dos coeficientes e termos fontes call coeficientes_e_fontes
! escrita dos coeficientes e termos fontes call lista_coeficientes
tcpu = timef() ! zera cronômetro
! solução do sistema de equações select case ( solver )

case ( 1 ) ! Eliminação 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 variável primária e sua visualização 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 (analítico e numérico)
open(7,file='T.dat')
write(10,1)
1 format(/,t4,'X',t28,'T (analítico)',t52,'T (numérico)',t76,'erro',/)
do i = 1, N
select case ( matriz )
case ( 1 ) ! fonte nulo
T_exato = (i-1.0d0) / (N-1)

case ( 2 ) ! fonte não-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 gráfico 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 gráfico de T
ver = system('wgnuplot comandos20a.gnu')
end subroutine escreve_T
!------------------------------------------------- end module resultados
program programa20a
! Difusão de calor unidimensional permanente
! Versão original 1.0 (25 Mai 07)
! Versão atual 1.0 (25 Mai 07)
! última alteração = 26 Mai 07

! autor: Carlos Henrique Marchi (Curitiba, DEMEC/UFPR)
! MODELO MATEMÁTICO (resumo)
! Equação diferencial: d2T/dx2 = S
! Condição de contorno de Dirichlet em x = 0: T(0) = 0
! Condição de contorno de Dirichlet em x = 1: T(1) = 1
! x = coordenada espacial (variável independente)
! T = temperatura (variável dependente)
! S = termo fonte
! Solução analítica conhecida da equação diferencial
! Solução analítica conhecida da equação discretizada
! MODELO NUMÉRICO (resumo)
! Incógnita (variável primária, dependente): T
! Método numérico: diferenças finitas
! Função de interpolação: CDS (variável primária T)
! As condições de contorno são aplicadas forçando os
! coeficientes e fontes a satisfazer a C.C.
! Malha uniforme
! Solvers: Eliminação de Gauss, Gauss-Seidel e TDMA
! Precisão: dupla
! Linguagem FORTRAN 95
! Aplicativo usado: Fortran 4.0 Microsoft
! Tipo de projeto: Console
! Expressão genérica do sistema de equações discretizado:
! aP(i)*T(i) = aw(i)*T(i-1) + ae(i)*T(i+1) + bP(i)
! onde i = 1, 2, ... N (número de nós)
! 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 equações e gera listagens dos resultados
! solvers_1D.f9 = Solvers Eliminação de Gauss, Gauss-Seidel e TDMA
! variaveis.f90 = define todas as variáveis globais do programa
! programa20a.ent = arquivo de dados do programa
! caso = listagem dos resultados
! T.dat = arquivo de dados para fazer gráfico
! comandos20a.gnu = arquivo de comandos para gerar gráfico
! notepad.exe = aplicativo editor dos arquivos tipo texto
! Wgnuplot.exe = aplicativo gerador de gráfico
! -----------------------------------------------

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(/,'Título = ', acomp,
//,5x,'Dia = ',a12,5x,'Hora = ',a8)

! alocação de memória 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 através de Build, Execute. Usar os dados mostrados na Figura 20.2.
16) Analisar os resultados mostrados nas Figuras 20.3 e 20.4. O erro apresentado pela solução na
Figura 20.4 deve-se aos erros de arredondamento.
17) Executar novamente o programa usando os mesmos dados da Figura 20.2, exceto, matriz = 1 e
analisar os novos resultados.

18) Executar novamente o programa usando os mesmos dados da Figura 20.2, exceto, matriz = 1 e solver = 3, e analisar os novos resultados. Notar a redução significativa no tempo de CPU ao se usar o método TDMA em relação ao método de Eliminação de Gauss.
19) Executar novamente o programa usando os mesmos dados da Figura 20.2, exceto, matriz = 2 e
solver = 3, e analisar os novos resultados.
20.2 EXERCÍCIOS

Exercício 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 variável “iteracao” que seja suficiente para satisfazer a tolerância (Tol) estipulada na Figura 20.2. Comparar o tempo de CPU resultante neste caso, para o método de Gauss-Seidel, àquele do método TDMA (item 18) e do método de Eliminação de Gauss (item
17).
Figura 20.4 Arquivo de resultados do programa20a.f90 para os dados da Fig. 20.2.
Exercício 20.2
Executar novamente o programa20a.f90 usando os mesmos dados da Figura 20.2, exceto, matriz = 2 e solver = 2. Por tentativa e erro, usar um valor para a variável “iteracao” que seja suficiente para satisfazer a tolerância (Tol) estipulada na Figura 20.2. Comparar o tempo de CPU resultante neste caso, para o método de Gauss-Seidel, àquele do método TDMA (item 19) e do método de Eliminação de Gauss (item
16).

Procedimento: Criar e inserir programa-fonte no projeto 1
Procedimento: CRIAR E INSERIR PROGRAMA-FONTE NO PROJETO
Explicações detalhadas estão na seção 1.7 do capítulo 1.
Para iniciar a edição ou escrita de um programa-fonte em linguagem FORTRAN é necessário criar e inserir um arquivo dentro do projeto. Isso é feito através 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 opção File Name, digitar o nome do programa-fonte a ser criado. Sempre deve-se usar f90 como extensão 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 botão 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 projeto do tipo Console Application 1
Procedimento: CRIAR PROJETO DO TIPO CONSOLE APPLICATION
Explicações detalhadas estão na seção 1.6 do capítulo 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 opção Project Workspace. Depois, clicar sobre o botão OK.
3) Na janela New Project Workspace, é necessário executar o que segue:
a) Entre os seis tipos de projetos apresentados na opção Type, clicar sobre Console Application no caso deste tipo de projeto não estar selecionado (realçado em azul).
b) Na opção Location estará indicado um diretório (pasta) default, ou seja, um diretório escolhido pelo próprio Fortran em função de sua configuração atual. É possível que não seja o diretório desejado. Neste caso, deve-se clicar sobre o botão Browse para indicar o diretório onde se quer criar o projeto. Ao se fazer isso, surgirá a janela Choose Directory na qual deve-se executar:
Na opção Drives, escolher Z:SERVER1Alunos2004_1
Na opção Directory name, clicar duas vezes sobre o nome do diretório que é idêntico ao user name usado para acessar a rede Windows do DEMEC/UFPR
Clicar sobre o botão OK.
c) Estará de volta a janela New Project Workspace. Clicar dentro do espaço de edição da opção Name. Escrever o nome do projeto. Deve-se perceber que o nome do projeto, digitado na opção Name, aparece automaticamente na opção Location. Em seguida, deve-se clicar sobre o botão Create. Após isso, o Fortran criará um diretório com o nome do projeto indicado, dentro do diretório já selecionado.

Procedimento: Fim de sessão 1
Procedimento: FIM DE SESSÃO
Workspace

REFERÊNCIAS BIBLIOGRÁFICAS
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. Lógica de Programação. 2a ed. São Paulo : Makron
Books, 2000.
HAHN, B. Fortran 90 for Scientists and Engineers. New York : Chapman Hall, 1994. MORAES, P. S. Curso Básico de Lógica de Programação. Campinas, 2000. RAMALHO, J. A. A. Introdução à Informática. São Paulo : Berkeley, 2000.
Referências bibliográficas 1

Fortran90 index

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Fortran90 index

Último

Fortran90 index