Fortran90 index

FORTRAN 90 PARA

WINDOWS

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).

ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/apostila_logica_programacao.pdf

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:\MSDEV\Projects, conforme é mostrado na Figura 1.7.

• Clicar sobre o botão OK.

c) Estará de volta a janela New Project Workspace, mostrada na Figura 1.5. Clicar dentro do espaço

de edição da opção Name. Escrever o nome do projeto, por exemplo, programa01. Depois disso,

a janela New Project Workspace deverá ficar conforme a Figura 1.8. Deve-se perceber que o

nome do projeto, digitado na opção Name, aparece automaticamente na opção Location. Em

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:\Msdev\Projects

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:\MSDEV\Projects\programa01\Debug\programa01.exe

3) Dentro desta janela, com fundo em preto, aparece o resultado da execução do programa. No caso, as

frases Meu primeiro programa em Fortran e Ano 2004. A ordem das duas frases é a mesma em que

elas foram colocadas no programa-fonte. Isso ocorre, porque o programa é executado do topo para

baixo, linha por linha do programa-fonte.

4) Além disso, também aparece a frase Press any key to continue. Como diz este aviso, basta clicar em

qualquer tecla para continuar. Ao fazer isso, a execução do programa é encerrada.

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

OBJETIVOS DO CAPÍTULO • Conceitos de: variáveis do tipo inteiro, atribuição, avisos e erros de compilação, erros de execução,

comentários dentro do programa-fonte

• Operadores matemáticos básicos • Comandos do FORTRAN: INTEGER e READ

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:\\SERVER1\Alunos2004_1\login,

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.


5) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 2.3,


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:\marchi\programa02\programa02b.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 1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho.

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 1) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho.

INTEGER A

A = 4

A = 3


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


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:\\SERVER1\Alunos2004_1\login,


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.




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

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


3) Para fechar o aplicativo Fortran, basta fazer o seguinte em seu menu: File, Exit




2.9 EXERÍCIOS Exercício 2.1

Executar novamente o programa03.f90, versão B, com A = 2 e B = −1. Em seguida, analisar cada

resultado, comparando-o com o valor esperado obtido de um cálculo mental, especialmente o caso da

potenciação. No Fortran, para abrir um projeto já existente, como o programa03, basta executar File,

Open Workspace. Em seguida, indicar o diretório do projeto e selecionar o arquivo que tem o nome

do projeto e extensão mdp, no caso programa03.mdp Exercício 2.2

Executar novamente o programa03.f90, versão B, usando números reais, isto é, A = 1.5 e B = 0.4.

Números reais são representados com o sinal de ponto para separar a parte inteira da decimal. Exercício 2.3

1) Editar um programa-fonte em FORTRAN para executar o seguinte algoritmo (passos):

a) ler três números inteiros

b) calcular a média aritmética deles

c) escrever os valores lidos e o valor da média aritmética juntamente com comentários para

identificá-los


2) Compilar o programa-fonte 3) Gerar o programa-executável

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

OBJETIVOS DO CAPÍTULO

� Conceitos de: variáveis do tipo real, tradução de expressões algébricas em FORTRAN, mistura de

variáveis do tipo inteiro com real, prioridade nas operações matemáticas

� Operadores matemáticos básicos

� Comando do FORTRAN: REAL

3.1 programa03c.f90


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


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


END

Figura 3.1 Programa03c.f90. 6) Executar Build, Compile para compilar o programa









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.


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.


READ(*,*) A

D = A

B = 1 / D

C = 1.0 / D WRITE(*,*) "Valor de D = ", D

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

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

END

4) Executar Build, Compile para compilar o programa









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:




projeto chamado programa03 o programa-fonte programa03e.f90


mostrado na Tabela 3.3. REAL A, B, C, D, E, F, G

Tabela 3.3 Programa03e.f90.


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










necessário digitar o valor 1.5 para a variável A, por exemplo, e, em seguida, clicar na tecla

enter.





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)

H 2 =

A + B C

(3.2)


H 3 =

A + B C

(3.3)

H 4 =

A + B D C

(3.4)

H 5 = A + B C D

(3.5)

H 6 = A + B C D (3.6)

H 9 = (C 3 )2 (3.7)

H = 1 B 3 (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:




projeto chamado programa03 o programa-fonte programa03f.f90


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.0�I)) * ( ( (I**2) + (1.0/(J**3)) ) ** (1.0/2) )

d) L = ( 1.0 / ( 1.0 + (1.0/I) ) ) * ( ( (I**2) + ( J / ( (I**3) � 2 ) ) ) ** (1.0/3) ) 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

OBJETIVOS DO CAPÍTULO • Conceitos de: variáveis do tipo caracter, strings, funções intrínsecas

• Funções intrínsecas do FORTRAN para variáveis do tipo caracter: ADJUSTL, ADJUSTR, TRIM e

LEN • Comando do FORTRAN: CHARACTER

4.1 programa4a.f90



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 programa04 no diretório Z:\\SERVER1\Alunos2004_1\login,


do DEMEC/UFPR.


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%, L&L. 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. 6) Executar Build, Compile para compilar o programa




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



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.

WRITE(*,*) "Conteudo de A = ", A 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:




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

WRITE(*,*) "Conteudo de A = ", 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,


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 1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no

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,


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,


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:







mostrado na Tabela 4.5. 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,


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


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

OBJETIVOS DO CAPÍTULO • Conceitos de: arquivo de saída, biblioteca, funções matemáticas intrínsecas

• Criar e usar arquivos para mostrar resultados da execução de um programa em FORTRAN

• Usar o aplicativo Notepad do Windows para mostrar o conteúdo de um arquivo durante a execução de

um programa em FORTRAN

• Funções matemáticas intrínsecas do FORTRAN • Comandos do FORTRAN: WRITE(número,*), OPEN, CLOSE, USE, SYSTEM

5.1 programa5a.f90



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 programa05 no diretório Z:\\SERVER1\Alunos2004_1\login,


do DEMEC/UFPR.


projeto o programa-fonte programa5a.f90




a) Até aqui o comando WRITE foi utilizado com dois asteriscos dentro do 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.


6) Executar Build, Compile para compilar o programa. 7) Gerar o programa-executável fazendo Build, Build.



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.




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


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.


Fortran:




projeto chamado programa05 o programa-fonte programa5b.f90


mostrado na Tabela 5.2. REAL A



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


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,




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:\Temp\saida5b.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.


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



READ(*,*) A

OPEN(7, file="saida5c.txt")


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:\Temp\saida5c.txt"), o comando correspondente para abrir automaticamente o arquivo

saida5c.txt é VER = SYSTEM ("Notepad C:\Temp\saida5c.txt").

5.4 programa5d.f90 1) Nesta 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.



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


READ(*,*) A

OPEN(8, file="saida5d.txt")


B = ABS(A)

WRITE(8,*) "B = Módulo de A =", B

C = LOG10(B)

WRITE(8,*) "C: Logaritmo decimal de B

=",

C

Pi = ACOS(-1.0)

WRITE(8,*) "Pi =", Pi

D = COS(Pi)

WRITE(8,*) "Cosseno de Pi =", D

D = COSH(Pi)

WRITE(8,*) "Cosseno hiperbólico de Pi

=",

D

CLOSE(8)

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 = e X 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


Tabela 5.6 Algumas funções trigonométricas do FORTRAN.


Seno Y = SIN(X) X em radianos

Cosseno Y = COS(X) X em radianos

Tangente Y = TAN(X) X em radianos

Arco-seno Y = ASIN(X) Y em radianos

Arco-cosseno Y = ACOS(X) Y em radianos

Arco-tangente Y = ATAN(X) Y em radianos

Seno 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

OBJETIVOS DO CAPÍTULO • Conceitos e comandos de formatos de edição para variáveis do tipo inteiro, caracter e real

• Regras de edição de programas-fonte em FORTRAN

• Seqüência obrigatória dos comandos dentro de programas-fonte em FORTRAN

• Comandos do FORTRAN: WRITE(número,número) e FORMAT

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



ftp://ftp.demec.ufpr.br/disciplinas/Tm102/Marchi/criar_projeto_console.pdf

ftp://ftp.demec.ufpr.br/disciplinas/Tm102/Marchi/criar_e_inserir_fonte.pdf



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



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 1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no

Fortran:




programa6b.f90



ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/marchi/criar_e_inserir_fonte.pdf



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" )

22 FORMAT ( I5, "= A no formato I5" )

23 FORMAT ( I10, "= A no formato I10" )

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


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.

8) Até entender, comparar o resultado de cada comando WRITE, e seu respectivo comando FORMAT

no programa6b.f90, mostrado em cada linha da Figura 6.4 ou no arquivo saida6b.txt. 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 1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no

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




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.

8) Até entender, comparar o resultado de cada comando WRITE, e seu respectivo comando FORMAT

no programa6c.f90, mostrado em cada linha da Figura 6.6 ou no arquivo saida6c.txt.

9) Executar novamente o programa com outros valores para as variáveis A e B. Analisar os novos

resultados.

10) Num mesmo comando FORMAT, podem ser usados identificados de variáveis do tipo inteiro,

caracter e real, além de comentários, e dos formatos NX, N/ e TN.

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.


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

ftp://ftp.demec.ufpr.br/disciplinas/Tm102/Marchi/fim_sessao.pdf


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

OBJETIVOS DO CAPÍTULO • Conceitos de: decisão, condição, operadores relacionais e lógicos, e opção

• Comandos do FORTRAN: IF – THEN – ELSE – END IF, SELECT CASE – CASE – END SELECT

7.1 programa7a.f90






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.

ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/marchi/criar_projeto_console.pdf




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. 8) Ao se executar o programa, através de Build, Execute, surge uma janela, mostrada na Figura 7.1,


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


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.


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.


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.


Fortran:




programa7c.f90




mostrado na Tabela 7.8. 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.



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.


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


ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/marchi/fim_sessao.pdf


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

OBJETIVOS DO CAPÍTULO • 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.







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.


Fortran:




programa8b.f90





Tabela 8.2 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.


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



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


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



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. 2) No Fortran, seguindo o procedimento-padrão, criar e inserir no projeto o programa-fonte

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.

Tabela 8.4 Programa8c.f90. 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.


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.



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

OBJETIVOS DO CAPÍTULO • Conceitos de: conjunto, elemento, alocação dinâmica de memória

• Comandos do FORTRAN: DIMENSION, ALLOCATABLE, ALLOCATE, MINVAL, MAXVAL,

SUM

9.1 programa9a.f90






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.


Figura 9.1 Resultado do programa9a.f90.

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

2) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no

Fortran:

a) Clicar sobre o nome do programa9a.f90

b) Edit, Cut para retirar o programa9a.f90 do projeto.


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.


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

Tabela 9.4 Programa9c.f90. 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.


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 1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no

Fortran:

a) Clicar sobre o nome do programa9c.f90

b) Edit, Cut para retirar o programa9c.f90 do projeto.


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





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.


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

∑( N m − N i ) 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.

Tabela 10.1 Programa10a.f90. 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


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 é DO LINHA = 1, LINHAS


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.



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 DO COLUNA = 1, COLUNAS

READ(*,*) MATRIZ(LINHA,COLUNA)

END DO

do programa, que contêm um ciclo que começa no elemento da primeira coluna e vai até a última.

Deve-se perceber que o comando READ é usado para ler o valor de apenas um elemento a cada

vez; assim é necessário digitar cada valor e, em seguida, clicar na tecla Enter antes de se digitar


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 DO LINHA = 1, LINHAS

WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A da linha =", LINHA

READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )

END DO

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) ) DO LINHA = 1, LINHAS

WRITE(*,*) "Entre com os valores dos elementos da MATRIZ_A da linha =", LINHA

READ(*,*) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )

END DO DO LINHA = 1, LINHAS


MATRIZ_B(LINHA,COLUNA) = CONSTANTE * MATRIZ_A(LINHA,COLUNA)


END DO

END DO DO LINHA = 1, LINHAS


MATRIZ_C(LINHA,COLUNA) = MATRIZ_A(LINHA,COLUNA) + MATRIZ_B(LINHA,COLUNA)

END DO

END DO

OPEN(10, FILE="SAIDA10B.TXT")

WRITE(10,31) CONSTANTE

31 FORMAT("CONSTANTE = ", I5, /) WRITE(10,32)

32 FORMAT(3X, "*** MATRIZ_A (dados) ***")


WRITE(10,33) ( MATRIZ_A(LINHA,COLUNA), COLUNA = 1, COLUNAS )

33 FORMAT( 10 (3X, 1PE10.3 ) )

END DO WRITE(10,41)

41 FORMAT(1/, 3X, "*** MATRIZ_B (CONSTANTE * MATRIZ_A) ***")


WRITE(10,33) ( MATRIZ_B(LINHA,COLUNA), COLUNA = 1, COLUNAS )

END DO

WRITE(10,51)

51 FORMAT(1/, 3X, "*** MATRIZ_C (MATRIZ_A + MATRIZ_B) ***")


WRITE(10,33) ( MATRIZ_C(LINHA,COLUNA), COLUNA = 1, COLUNAS )

END DO CLOSE(10)

VER = SYSTEM("Notepad SAIDA10B.TXT")

END

c) Com o bloco de linhas do programa




MATRIZ_B(LINHA,COLUNA) = CONSTANTE * MATRIZ_A(LINHA,COLUNA)

END DO

END DO

o valor de cada elemento da MATRIZ_A é multiplicado pela 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 DO LINHA = 1, LINHAS

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.


CONSTANTE, resultado do comando READ(*,*) CONSTANTE do programa. Para que o programa


Figura 10.2 Janela DOS do programa10b.f90.

c) Na terceira linha, o 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


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


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.




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 com Wgnuplot 130

Capítulo 11. GRÁFICOS COM WGNUPLOT

OBJETIVOS DO CAPÍTULO • Aprender a utilizar o aplicativo Wgnuplot para fazer gráficos

• Aprender a utilizar o aplicativo Wgnuplot interativamente com um programa em FORTRAN

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


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.


ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/

ftp://ftp.demec.ufpr.br/Disciplinas/Tm102/Marchi/Wgnuplot.pdf


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.



PONTOS, resultado do comando READ(*,*) PONTOS do programa. Para que o programa continue


Figura 11.7 Janela DOS do programa11.f90.

c) Em seguida, o aplicativo Notepad apresenta as coordenadas x e y, onde y = x3, gravadas no

arquivo chamado DADOS.TXT, cujo 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.





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

OBJETIVOS DO CAPÍTULO • Conceitos de: sub-rotina, programa-principal, projeto com diversos programas-fonte, passagem de

argumentos

• Comandos do FORTRAN: PROGRAM, EXTERNAL, SUBROUTINE, CALL, CONTAINS

12.1 programa12a




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.


READ(*,*) A

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

READ(*,*) B

CALL SOMA ( A, B, C )

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

END PROGRAM CAPITULO_12A

e) Quando há mais de um programa-fonte no projeto, primeiro deve-se compilar os programas-fonte

que 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.





necessário digitar 1, por exemplo, e, em seguida, clicar na tecla Enter.





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



READ(*,*) A


READ(*,*) B


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

WRITE(*,*) "Entre com um valor inteiro para calcular seu fatorial"

READ(*,*) INTEIRO

CALL FATORIAL ( INTEIRO )

END PROGRAM CAPITULO_12B





rotinas2.f90



Tabela 12.4 Programa-fonte rotinas2.f90. 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.



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.


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


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.


READ(*,*) A


READ(*,*) B


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


READ(*,*) INTEIRO

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


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


READ(*,*) A


READ(*,*) B


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



READ(*,*) INTEIRO

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

13.1 programa13a.f90 1) Objetivos do programa:

a) Definir uma variável do tipo real de dupla precisão usando o comando REAL*8

b) Comparar a precisão de variáveis do tipo real simples e dupla



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.

13) No Fortran, para fechar o projeto atual, executar File, Close Workspace 13.2 programa13b.f90


a) Usar diversas formas para definir variáveis reais simples e dupla

b) Realizar cálculos elementares envolvendo variáveis do tipo inteiro, real simples e real dupla

2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13b


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



READ(*,*) A

D = A

B = 1 / D

C = 1.0 / D E = A

F = 1 / D

G = 1.0 / D

WRITE(*,*) "Valor de D (inteiro) = ", D

WRITE(*,*) "Valor de B (real simples) = ", B

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

WRITE(*,*) "Valor de F (real dupla) = ", F

WRITE(*,*) "Valor de G (real dupla) = ", G END

10) Executar novamente o programa com outros valores para a 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 1) Objetivos do programa:

a) Mostrar a importância de serem definidas todas as variáveis de um programa

b) Utilizar o comando IMPLICIT NONE

2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13c


programa13c.f90


mostrado na Tabela 13.2, isto é, copiar o programa13b.f90 do projeto anterior.

5) Eliminar a primeira linha do programa, ou seja, INTEGER D.

6) Executar Build, Compile para compilar o programa. Mesmo a 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.

15) No Fortran, para fechar o projeto atual, executar File, Close Workspace IMPLICIT NONE

INTEGER D

REAL A

REAL*4 B

REAL(4) C REAL*8 E

REAL(8) F

DOUBLE PRECISION G



READ(*,*) A


D = A

B = 1 / D

C = 1.0 / D E = A

F = 1 / D

G = 1.0 / D

WRITE(*,*) "Valor de D (inteiro) = ", D

WRITE(*,*) "Valor de B (real simples) = ", B

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

WRITE(*,*) "Valor de F (real dupla) = ", F

WRITE(*,*) "Valor de G (real dupla) = ", G END

13.4 programa13d.f90 1) Objetivos do programa:

a) Usar funções matemáticas intrínsecas do FORTRAN com variáveis reais do tipo dupla

b) Usar formatos de edição com variáveis reais do tipo dupla

2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa13d


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.


Módulo ou valor absoluto Y = DABS(X)

Raiz quadrada Y = DSQRT(X)

Exponencial: Y = e X 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


Máximo Y = DMAX1(X,Z,W) Y = valor máximo entre X, Z e W; o


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.


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) 6) Executar Build, Compile para compilar o programa


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.



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

OBJETIVOS DO CAPÍTULO • Conceitos de: arquivo de entrada, arquivo interno, arquivo texto, arquivo binário, dispositivo e nome

de arquivo genéricos

• Comandos do FORTRAN: uso avançado de OPEN, WRITE e SYSTEM • No comando OPEN, usar os parâmetros FORMATTED, UNFORMATTED, REWIND e APPEND

Para inicializar as atividades deste capítulo, deve-se acessar o programa Fortran, no Windows,


14.1 programa14a.f90 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


14.2 programa14b.f90 1) Objetivos do programa:

(a) Entrada de dados através de janela DOS;

(b) escrever resultados num arquivo cujo nome e o número do dispositivo são genéricos e definidos

pelo usuário através dos dados do programa; e

(c) abrir o arquivo de resultados de nome genérico com o aplicativo Notepad.





programa14b.f90



USE PORTLIB

IMPLICIT NONE

REAL*8 Pi

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. 9) Executar o programa através de Build, Execute com:





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.

14.3 programa14c.f90 1) Objetivo do programa: adicionar resultados num arquivo já existente.





programa14c.f90


mostrado na Tabela 14.2, que é o programa14b.f90.

5) Alterar a linha OPEN(UNIT, file = SAIDA )

para OPEN(UNIT, file = SAIDA, position = "rewind" )


O 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 1) Objetivos do programa:

(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. 2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa14d


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”. USE PORTLIB

IMPLICIT NONE

REAL*8 Pi

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


WRITE(UNIT,11) UNIT, Pi, SAIDA, TEXTO

CLOSE(UNIT)

11 FORMAT( 1/, 5X, "UNIT =", I4, &

1/, 5X, "Pi =", 1PE25.15, &

1/, 5X, "SAIDA = ", A50, &

1/, 5X, "TEXTO = ", A50 )


END

(c) Nas linhas READ(1,*) UNIT e READ(1,*) SAIDA os dois dados 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. USE PORTLIB

IMPLICIT NONE

REAL*8 Pi

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) 11 FORMAT( 1/, 5X, "UNIT =", I4, &

1/, 5X, "Pi =", 1PE25.15, &

1/, 5X, "SAIDA = ", A30, &

1/, 5X, "TEXTO = ", A30, &

1/, 5X, "TEXTO2 = ", A30, &

1/, 5X, "TEXTO3 = ", A30, &

1/, 5X, "TEXTO4 = ", A70, &

1/, 5X, "TEXTO5 = ", A30 )


END








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.



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

OBJETIVOS DO CAPÍTULO • Inicializar variáveis e constantes junto com suas definições

• Versões DEBUG e RELEASE de um programa-executável

• Comandos do FORTRAN: PARAMETER, Formato A<X>

• Função do FORTRAN: TIMEF

• Comandos do DOS: MKDIR, COPY, ERASE, CD, RENAME, “arquivo”.BAT




(a) usar os novos comandos do FORTRAN: PARAMETER e formato A<X>

(b) ao definir variáveis, inicializar seus valores; e

(c) escrever variáveis do tipo caracter com tamanho exato de seu conteúdo, usando o comando

FORMAT.



programa15a.f90


mostrado na Tabela 15.1. 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)


WRITE(UNIT,10) UNIT, Pi

10 FORMAT( /, 5X, "UNIT = ", I4, &

2/, 5X, "Pi = ", 1PE25.15 ) WRITE(UNIT,11) COMENTARIO

11 FORMAT( /, A50, " = COMENTARIO" )

X = LEN(TRIM(ADJUSTL(COMENTARIO)))

WRITE(UNIT,12) TRIM(ADJUSTL(COMENTARIO))

12 FORMAT( /, A<X>, " = COMENTARIO" )

CLOSE(UNIT)



END


(a) Na linha INTEGER :: UNIT = 20 está sendo definida a 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( /, A<X>, " = 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 A<X>, 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.


15.2 programa15b.f90



(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. 2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome programa15b


programa15b.f90



USE PORTLIB

IMPLICIT NONE

INTEGER VER, PASSOS, I

CHARACTER(50) SAIDA, TEXTO INTEGER :: UNIT = 20 REAL*8 T1, T2, SOMA


VER = SYSTEM("Notepad DADOS.TXT" )


READ(1,*) PASSOS

READ(1,*) SAIDA




CLOSE(1)

T1 = TIMEF()

SOMA = 0.0D0

DO I = 1, PASSOS

SOMA = SOMA + I

END DO T2 = TIMEF() OPEN(UNIT, file = SAIDA ) 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)



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.




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.


15.3 programa15c.f90 1) Objetivo do programa: utilizar comandos do DOS durante a execução do programa.



programa15c.f90


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" )


READ(1,*) COMENTARIO

READ(1,*) SAIDA CLOSE(1)


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:\TEMP\FORTRAN"

WRITE(UNIT,*) "COPY " // TRIM(SAIDA) // " C:\TEMP\FORTRAN\" // TRIM(SAIDA)

WRITE(UNIT,*) "ERASE " // TRIM(SAIDA)

WRITE(UNIT,*) "CD C:\TEMP\FORTRAN\" WRITE(UNIT,*) "RENAME "// TRIM(SAIDA) // " NOVO.TXT"

CLOSE (UNIT)

! fim


DOS = SYSTEM ( "EXECUTA.BAT" )

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

END


(a) O comando do DOS chamado MKDIR é usado para criar um novo 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.




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:\TEMP\FORTRAN\”

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:\TEMP\FORTRAN\”; 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.


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:\TEMP\FORTRAN\”

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

OBJETIVOS DO CAPÍTULO • Estimar e verificar a memória computacional necessária para executar um programa

• Utilizar sub-rotina recursiva

• Controlar o fluxo de informações para dentro e para fora de sub-rotinas

• Comandos do FORTRAN: DEALLOCATE, RECURSIVE, INTENT(IN,OUT,INOUT)




(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 + N real 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

INTEGER :: UNIT = 20 WRITE(*,*) "Ver memoria em uso no primeiro comando; depois clique Enter"

READ(*,*) VER = SYSTEM("Notepad DADOS.TXT" )


READ(1,*) N

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

READ(*,*) A = 1


B = 1.0D0

C = "caracteres"

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

READ(*,*) M1 = N*4.0 / 1024 M2 = N*8.0 / 1024 M3 = N*1.0*10 / 1024 M4 = M1 + M2 + M3


WRITE(UNIT,*) "Memoria estimada para A, inteiros (kiloBytes) = ", M1

WRITE(UNIT,*) "Memoria estimada para B, reais (kiloBytes) = ", M2

WRITE(UNIT,*) "Memoria estimada para C, caracteres (kiloBytes) = ", M3

WRITE(UNIT,*) "Memoria estimada para A, B e C (kiloBytes) = ", M4 CLOSE(UNIT)



DEALLOCATE ( A )

WRITE(*,*) "Ver memoria com B e C"

READ(*,*) DEALLOCATE ( B )

WRITE(*,*) "Ver memoria com C"

READ(*,*)

DEALLOCATE ( C )

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

READ(*,*) END





dados. No caso do programa16a.f90, é 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

16.2 programa16b.f90


(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. 4) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto em vermelho



(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.




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


elementos são do tipo real dupla, com X2 por Y2 elementos. Exercício 16.3


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

OBJETIVOS DO CAPÍTULO • 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.

11) Gerar o programa-executável fazendo Build, Build. 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.

14) No Fortran, para fechar o projeto atual, executar File, Close Workspace. 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

17.2 programa17b.f90 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




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


ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17b/


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




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.


ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/programa17c/


(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.


(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

OBJETIVOS DO CAPÍTULO • Calcular o resultado de séries infinitas • Aplicar os métodos de iteração linear, bisseção e Newton para determinar raízes de equações

• Revisar o uso de arquivos de dados e de resultados, Notepad e Wgnuplot

• Alterar dinamicamente arquivo de comandos do programa de gráficos Wgnuplot e usar novos

comandos




(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.


ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_18



(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



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 !------------------------------------------------- subroutine serie_2

! 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 erro = dabs(exato - soma) write(6,10) i, termo, soma, erro 10 format( i8, 3(1pe30.15e3) )

end do

end subroutine serie_2 !------------------------------------------------- subroutine serie_3

! 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 erro = dabs(exato - soma)

write(6,10) i, termo, soma, erro

10 format( i8, 3(1pe30.15e3) ) end do

end subroutine serie_3 !------------------------------------------------- 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.


18.2 programa18b.f90 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,




(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

x 2 − 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.

ftp://ftp.demec.ufpr.br/Disciplinas/Tm784/projeto_18



16) Executar novamente o programa usando tipo_metodo = 2 e analisar os novos resultados.

17) Executar novamente o programa usando tipo_metodo = 3 e analisar os novos resultados.

18) Executar novamente o programa usando tipo_metodo = 3, n = 20, exato = 3 e xo = 100 e analisar

os novos resultados.



program raizes

use portlib


implicit none

integer :: i, n, ver, tipo_metodo

real*8 :: exato, erro, xo, x, r call dados

x = xo

open(6,file="saida18b.txt")

write(6,10)

10 format("# i", t17,"x", t47,"erro") erro = dabs(exato - x)

write(6,11) 0, x, erro

11 format( i8, 2(1pe30.15e3) ) select case ( tipo_metodo )

case ( 1 )

call linear

case ( 2 )

call bissecao

case ( 3 )

call newton

end select close(6) ver = system ("Notepad saida18b.txt")


call grafico !-------------------------------------------------

contains

!-------------------------------------------------

subroutine dados

ver = system ("Notepad dados18b.txt")

open(5,file="dados18b.txt")

read(5,*) tipo_metodo

read(5,*) n

read(5,*) exato

read(5,*) xo

read(5,*) r

close(5) end subroutine dados !-------------------------------------------------

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



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



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

write(9,*) "replot"

close(9)

ver = system ("Wgnuplot comandos18b.gnu") end subroutine grafico

!-------------------------------------------------

end program raizes

Figura 18.4 Arquivo de dados do programa18b.f90.



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:

x 2 − 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

OBJETIVOS DO CAPÍTULO • Calcular derivadas numéricas com quatro tipos de aproximações numéricas do método de diferenças

finitas: UDS, DDS, CDS-2 e CDS-4.

• Calcular integrais numéricas com três tipos de aproximações numéricas: regras do retângulo, trapézio e Simpson.


através de: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio 19.1 programa19a.f90

1) Objetivo do programa: calcular derivadas numéricas com quatro tipos de aproximações numéricas do

método de diferenças finitas: UDS, DDS, CDS-2 e CDS-4.

2) No Fortran, seguindo o procedimento-padrão, criar um projeto com o nome projeto_19






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)

end subroutine dados !------------------------------------------------- subroutine exponencial

real*8 :: xw, h, fp, fw, fl_UDS, fl_DDS, xe, fe, fl_CDS2, &

xww, xee, fww, fee, fl_CDS4

! calcula a derivada da exponencial de X

exato = dexp(X)

do i = 0, L

h = hmax / ( r ** i )

xw = X - h xe = X + h xww = X - 2*h xee = X + 2*h

fp = dexp(x) fw = dexp(xw) fe = dexp(xe) fww = dexp(xww) fee = dexp(xee)

fl_UDS = ( fp - fw ) / h fl_DDS = ( fe - fp ) / h fl_CDS2 = ( fe - fw ) / (2 * h)


fl_CDS4 = ( 8*fe - 8*fw + fww - fee ) / (12 * h)

write(6,10) h, dabs(exato-fl_UDS), dabs(exato-fl_DDS), &

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

10 format( 5(1pe15.5) )

end do end subroutine exponencial !------------------------------------------------- subroutine potencia

real*8 :: xw, h, fp, fw, fl_UDS, fl_DDS, xe, fe, fl_CDS2, &

xww, xee, fww, fee, fl_CDS4

! calcula a derivada de X**5 exato = 5*X**4 do i = 0, L

h = hmax / ( r ** i )

xw = X - h xe = X + h xww = X - 2*h xee = X + 2*h

fp = x**5 fw = xw**5 fe = xe**5 fww = xww**5 fee = xee**5

fl_UDS = ( fp - fw ) / h fl_DDS = ( fe - fp ) / h fl_CDS2 = ( fe - fw ) / (2 * h) fl_CDS4 = ( 8*fe - 8*fw + fww - fee ) / (12 * h)

write(6,10) h, dabs(exato-fl_UDS), dabs(exato-fl_DDS), &

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


10 format( 5(1pe15.5) )

end do end subroutine potencia !------------------------------------------------- subroutine grafico

integer k

open(9,file="comandos19a.gnu")

do k = 1, 12 read(9,*)

end do

select case ( tipo_funcao )

case ( 1 )

write(9,*) "set title 'derivada de exponencial(X)'" case ( 2 )

write(9,*) "set title 'derivada de X**5'" end select

write(9,*) "replot" close(9) ver = system ("Wgnuplot comandos19a.gnu")

end subroutine grafico !------------------------------------------------- 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.



19.2 programa19b.f90 1) Objetivo do programa: calcular integrais numéricas com três tipos de aproximações numéricas:

regras do retângulo, trapézio e Simpson.


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,




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

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)

end subroutine dados !-------------------------------------------------

subroutine exponencial

real*8 :: xp, fp, ret, trap, xw, fw, simp, xe, fe

! calcula a integral da exponencial de X entre 0 e 1

exato = dexp(1.0d0) - 1

do i = 0, L

h = 1.0d0 / ( Nmin * (r ** i) )

ret = 0.0d0

trap = 0.0d0

do j = 1, Nmin*(r**i)

xp = h*(j-0.5d0)

fp = dexp(xp)

ret = ret + fp * h

xp = h*j

xw = xp - h

fw = dexp(xw)

fp = dexp(xp)

trap = trap + h*(fw+fp)/2

end do


simp = 0.0d0

do j = 2, Nmin*(r**i), 2

xp = h*(j-1)

xw = xp - h

xe = xp + h

fw = dexp(xw)

fe = dexp(xe)

fp = dexp(xp)

simp = simp + h*(fw+4*fp+fe)/3

end do

write(6,10) h, dabs(exato-ret), dabs(exato-trap), dabs(exato-simp)

10 format( 4(1pe15.5) )

end do end subroutine exponencial !-------------------------------------------------

subroutine potencia

real*8 :: xp, fp, ret, trap, xw, fw, simp, xe, fe

! calcula a integral de X**5 entre 0 e 1

exato = 1 / 6.0d0

do i = 0, L

h = 1.0d0 / ( Nmin * (r ** i) )

ret = 0.0d0

trap = 0.0d0

do j = 1, Nmin*(r**i)

xp = h*(j-0.5d0)


fp = xp**5

ret = ret + fp * h

xp = h*j

xw = xp - h

fw = xw**5

fp = xp**5

trap = trap + h*(fw+fp)/2

end do

simp = 0.0d0

do j = 2, Nmin*(r**i), 2

xp = h*(j-1)

xw = xp - h

xe = xp + h

fw = xw**5

fe = xe**5

fp = xp**5

simp = simp + h*(fw+4*fp+fe)/3

end do

write(6,10) h, dabs(exato-ret), dabs(exato-trap), dabs(exato-simp)

10 format( 4(1pe15.5) )

end do end subroutine potencia !-------------------------------------------------

subroutine grafico

integer k

open(9,file="comandos19b.gnu")

do k = 1, 11

read(9,*)

end do

select case ( tipo_funcao )


case ( 1 )

write(9,*) "set title 'integral de exponencial(X) entre 0 e 1'"

case ( 2 )

write(9,*) "set title 'integral de X**5 entre 0 e 1'"

end select

write(9,*) "replot"

close(9)

ver = system ("Wgnuplot comandos19b.gnu") end subroutine grafico

!-------------------------------------------------

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. 12) Executar Build, Compile para compilar o programa.



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.



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

OBJETIVOS DO CAPÍTULO • Aplicar, num único programa, diversos recursos e comandos do FORTRAN vistos nos capítulos

anteriores.

• Resolver sistemas de equações lineares com métodos diretos e iterativos.



20.1 programa20a.f90 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,


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 :: it ! número da iteração

integer :: ite ! número de iterações


real*8, intent(in) :: Tol ! tolerância sobre R

real*8,intent(in), dimension(N) :: a ! coeficiente aP





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(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


real*8 :: div ! variável auxiliar


real*8,dimension(:),allocatable :: P ! coeficiente do tdma

real*8,dimension(:),allocatable :: Q ! coeficiente do tdma

real*8,intent(in), dimension(N) :: a ! coeficiente aP





allocate(P(N),Q(N))

P(1) = c(1) / a(1)

Q(1) = d(1) / a(1)

do i = 2, N

div = a(i) - b(i)*P(i-1)

P(i) = c(i) / div

Q(i) = (d(i) + b(i)*Q(i-1))/div


end do

T(N) = Q(N)

do i = N-1, 1, -1

T(i) = P(i)*T(i+1) + Q(i)

end do

deallocate(P,Q)

end subroutine tdma

!-------------------------------------------------

end module solvers_1D

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',//, &

a<comp>,' = caso',/, &

i6,' = número de nós',/, &

i6,' = tipo de matriz: 1 = fonte nulo; 2 = fonte não-nulo',/, &

i6,' = tipo de solver: 1=El.Gauss; 2=GS; 3=TDMA',/, &

i6,' = número de iterações para o GS',/, &

1pe10.2,' = tolerância sobre o resíduo para o GS')

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

Tabela 20.6 Programa20a.f90 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 = ', a<comp>, &

//,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.



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.


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 3) Na janela Microsoft Developer Studio, 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

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:\\SERVER1\Alunos2004_1

Na opção Directory name, clicar duas vezes sobre o nome do diretório que é idêntico ao

user name usado para acessar a rede Windows do DEMEC/UFPR

Clicar sobre o botão OK.

c) Estará de volta a janela New Project Workspace. Clicar dentro do espaço de edição da opção

Name. Escrever o nome do projeto. Deve-se perceber que o nome do projeto, digitado na opção

Name, aparece automaticamente na opção Location. Em seguida, deve-se clicar sobre o botão

Create. Após isso, o Fortran criará um diretório com o nome do projeto indicado, dentro do

diretório já selecionado.

Procedimento: Fim de sessão 1

Procedimento: FIM DE 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




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

Education

Fortran90 index