Fortran90 index

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

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

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

5
11.6 EXERCÍCIOS ................................................................................................................................................... 140
Capítulo 12. SUB-ROTINAS ............................................................................................................................................ 141
12.1 programa12a ................................................................................................................................................ 141
12.2 programa12b ................................................................................................................................................ 145
12.3 programa12c ................................................................................................................................................. 148
12.4 programa12d ................................................................................................................................................ 150
12.5 EXERCÍCIO ..................................................................................................................................................... 153
Capítulo 13. VARIÁVEIS DO TIPO REAL DUPLA ............................................................................................................. 154
13.1 programa13a.f90 .......................................................................................................................................... 154
13.3 programa13c.f90 .......................................................................................................................................... 158
13.4 programa13d.f90 .......................................................................................................................................... 160
13.5 EXERCÍCIOS ................................................................................................................................................... 163
Capítulo 14. ARQUIVOS DE SAÍDA, DE ENTRADA E INTERNOS ..................................................................................... 165
14.1 programa14a.f90 .......................................................................................................................................... 165
14.2 programa14b.f90 .......................................................................................................................................... 166
14.3 programa14c.f90 .......................................................................................................................................... 169
14.4 programa14d.f90 .......................................................................................................................................... 170
14.5 programa14e.f90 .......................................................................................................................................... 174
14.6 EXERCÍCIOS ................................................................................................................................................... 176
Capítulo 15. INICIALIZAÇÃO, TEMPO DE CPU E DOS .................................................................................................... 178
15.1 programa15a.f90 .......................................................................................................................................... 178
15.2 programa15b.f90 .......................................................................................................................................... 180
15.3 programa15c.f90 .......................................................................................................................................... 185
15.4 EXERCÍCIOS ................................................................................................................................................... 189
Capítulo 16. MEMÓRIA E SUB-ROTINAS 2 .................................................................................................................... 191

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

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

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

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

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

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

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

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

Capítulo 1. Introdução 14
Figura 1.9 Fortran com o nome do diretório criado para o projeto especificado.
1.7 CRIAÇÃO E INSERÇÃO DO PROGRAMA-FONTE DENTRO DO PROJETO
O processo de edição ou criação de um programa é semelhante à redação de uma carta com o aplicativo Word, que é um editor de textos. São necessários dois componentes: um editor de textos para escrever o programa computacional e um arquivo para guardar o texto no hard disk (HD) do computador. No caso dos programas computacionais, a carta é chamada de programa-fonte e pode ser aberta, editada ou redigida dentro do Fortran ou em qualquer outro editor de textos. Ao longo deste texto, as palavras edição, digitação e implementação serão usadas como sinônimos. Para iniciar a edição ou escrita de um programa-fonte em linguagem FORTRAN é necessário criar e inserir um arquivo dentro do projeto. Isso é feito através dos seguintes passos:
1) No menu do Fortran, conforme é mostrado na Figura 1.10, executar: Insert, Files into Project
2) Na janela Insert Files into Project, mostrada na Figura 1.11, executar o seguinte:
a) Na opção File Name, digitar o nome do programa-fonte a ser criado; por exemplo, como mostrado na Figura 1.12, programa01.f90
Sempre deve-se usar f90 como extensão dos nomes dos arquivos do tipo programa-fonte. Ele indica que o programa está ou será escrito na linguagem FORTRAN 90 ou 95.

b) Clicar sobre o botão OK
Figura 1.10 Início da criação do programa-fonte.
Figura 1.11 Janela para definição do nome do programa-fonte a inserir no projeto.
3) Na janela Microsoft Developer Studio, mostrada na Figura 1.13, clicar sobre o botão Yes
4) Na subjanela do lado esquerdo do Fortran, clicar sobre o sinal + ao lado do nome do projeto; deverá aparecer o nome do programa-fonte que foi inserido no projeto; no caso, programa01.f90
5) Clicar rapidamente duas vezes sobre o nome do programa-fonte que foi inserido

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

Figura 1.15 Fortran pronto para edição do programa-fonte.
1.8 EDIÇÃO DO PROGRAMA-FONTE
Após a criação e inserção do programa-fonte dentro do projeto, o Fortran está pronto para ser usado na edição do programa-fonte, conforme mostrado na Figura 1.15. Um exemplo de edição de programa-fonte é apresentado a seguir.
1) Dentro do espaço de edição do Fortran, na subjanela maior, copiar exatamente o texto mostrado abaixo em vermelho (para aparecerem as aspas, deve-se clicar sobre a tecla delas e, em seguida, clicar sobre a tecla de espaço em branco).
WRITE(*,*) "Meu primeiro programa em FORTRAN" WRITE(*,*) "Ano 2004"
END
2) Para gravar ou salvar este texto, no menu do Fortran, executar: File, Save. Em seguida, na extremidade inferior da janela principal do Fortran, surgirá uma mensagem informando o diretório e o nome do programa-fonte que foi gravado ou salvo, como mostrado na Figura 1.16.
3) Comentários sobre este programa:

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

(escrito na linguagem dos computadores, usando apenas os algarismos zero-0 e um-1). Uma linguagem de programação de alto nível (Ramalho, 2000) como o FORTRAN se constitui numa forma “amigável” ou relativamente fácil de se escrever programas. O aplicativo Fortran PowerStation 4.0, além do editor de programas, também tem junto um compilador de programas. Para compilar um programa-fonte que está aberto no editor de textos do Fortran, deve-se executar o seguinte no menu do Fortran: Build, Compile
Após a compilação, conforme é mostrado na Figura 1.17, aparecerão três linhas com mensagens na subjanela da parte inferior do Fortran:
1) A primeira informa que o Fortran está compilando (Compiling) o programa-fonte.
2) A segunda informa o nome e o diretório do programa-fonte que está sendo compilado.
3) Finalmente, a terceira informa o nome do programa-objeto (no caso, programa01.obj) que foi gerado e o número de erros (errors) e de avisos (warnings) relativos ao programa-fonte compilado. Se houver algum erro, o programa-objeto não é gerado. Avisos não impedem a geração do programa-objeto. O nome do programa-objeto é igual ao nome do programa-fonte mas com extensão obj
Figura 1.17 Compilação do programa-fonte.
A compilação cria automaticamente um subdiretório chamado Debug dentro do diretório do projeto. Dentro deste subdiretório é que se encontra o programa-objeto bem como outros arquivos auxiliares. Pode-se ver isso com o aplicativo Windows NT Explorer, que é acessado executando o

seguinte no Windows: Start, Programs, Windows NT Explorer. Depois, deve-se acessar o diretório do projeto, que deve estar dentro do diretório C:MsdevProjects
1.10 GERAÇÃO DO PROGRAMA-EXECUTÁVEL
Após o processo de compilação, é necessário gerar o programa-executável, que é um arquivo possível de ser executado ou “rodado” pelo computador, como qualquer outro programa ou aplicativo; por exemplo, os aplicativos Word, Excel, PowerPoint, FrontPage, CorelDraw, Acrobat, e o navegador Internet Explorer. O programa-executável resulta da união do programa-objeto, que foi gerado na compilação do programa-fonte, com outros programas-objeto da própria linguagem FORTRAN, que contêm a tradução dos comandos do FORTRAN, como o WRITE e END usados no primeiro programa- fonte (Figura 1.17).
Para gerar o programa-executável, deve-se fazer o seguinte no menu do Fortran: Build, Build. Em seguida, conforme é mostrado na Figura 1.18, aparecerão duas linhas com mensagens na subjanela da
parte inferior do Fortran:
Figura 1.18 Geração do programa-executável.

1) A primeira informa que o Fortran está gerando o programa-executável, processo chamado de lincagem (linking).
2) A segunda informa o nome do programa-executável (no caso, programa01.exe) que foi gerado e o número de erros (errors) e de avisos (warnings) relacionados a ele. O nome do programa-executável é igual ao nome do projeto mas com extensão exe
O programa-executável é gravado automaticamente dentro do subdiretório Debug, que fica dentro do diretório do projeto, além de outros arquivos auxiliares. Isso pode ser visto com o aplicativo Windows NT Explorer, como mostrado na Figura 1.19. Note nesta figura que no Windows NT Explorer a extensão
ou Type do programa-executável aparece como Application.
Figura 1.19 Diretório do projeto programa01 e seu subdiretório Debug.
1.11 EXECUÇÃO DO PROGRAMA
Após gerar o programa-executável, para executá-lo ou “rodá-lo”, isto é, para colocá-lo em funcionamento, basta fazer o seguinte no menu do Fortran: Build, Execute. Como resultado deste comando, deve ocorrer o seguinte:
1) Aparecer uma janela do tipo DOS, conforme a Figura 1.20. Isso ocorre porque na seção 1.6 foi criado um projeto do tipo Console Application.

2) No título desta janela, com fundo em azul, aparece o nome do programa que está sendo executado e o diretório no qual ele se encontra, no caso C:MSDEVProjectsprograma01Debugprograma01.exe
3) Dentro desta janela, com fundo em preto, aparece o resultado da execução do programa. No caso, as frases Meu primeiro programa em Fortran e Ano 2004. A ordem das duas frases é a mesma em que elas foram colocadas no programa-fonte. Isso ocorre, porque o programa é executado do topo para baixo, linha por linha do programa-fonte.
4) Além disso, também aparece a frase Press any key to continue. Como diz este aviso, basta clicar em
qualquer tecla para continuar. Ao fazer isso, a execução do programa é encerrada.
Figura 1.20 Resultado da execução do programa01.
1.12 FIM DA SESSÃO
Para concluir o uso do Fortran e do Windows, deve-se executar o seguinte:
1) Para encerrar as atividades com um projeto, basta executar no menu do Fortran: File, Close
Workspace
2) Na janela Microsoft Developer Studio, clicar sobre o botão Yes
3) Para fechar o aplicativo Fortran, basta fazer o seguinte em seu menu: File, Exit
4) Para fechar o Windows, executar: Start, Shut Down…
5) Na janela Shut Down Windows, escolher a opção Close all programs and log on as a different user?. Clicar sobre o botão Yes

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

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

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

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

do FORTRAN são utilizados de forma incorreta. Na subjanela inferior do Fortran, geralmente haverá um comentário indicando cada erro (error). Logo após o nome do programa-fonte compilado, entre parênteses, é indicado o número da linha do programa-fonte aonde deve estar o erro. No exemplo da Figura 2.4, o compilador do Fortran mostra o seguinte comentário: C:marchiprograma02programa02b.f90(3): error FOR3852: syntax error detected between , and ). Portanto, este comentário indica que na linha 3 há um erro de sintaxe (erro que resulta do uso incorreto de um comando, no caso o WRITE) entre a vírgula e o sinal de fechamento de parênteses.
8) As linhas do programa-fonte são numeradas do topo para baixo, e as colunas, da esquerda para a direita. Na extremidade inferior da janela principal do Fortran, do lado direito, sempre são indicados a
linha (Ln) e a coluna (Col) aonde o cursor se encontra dentro do programa-fonte.
Figura 2.3 Resultado da execução do programa02.f90, versão B.
Figura 2.4 Exemplo de erro de compilação.
2.3 programa02.f90, versão C
INTEGER A A = 3
WRITE(*,*) "Valor de A = ", A

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

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

Figura 2.6 Programa02.f90, versão E.
2.6 programa03.f90, versão A
Para inicializar as atividades com o próximo programa, deve-se executar:
1) No Fortran, para fechar o projeto atual: File, Close Workspace
3) No Fortran, seguindo o procedimento apresentado na seção 1.6 do capítulo 1, criar um projeto do tipo Console Application com o nome programa03 no diretório Z:SERVER1Alunos2004_1login, onde login deve ser substituído pelo user name do usuário, isto é, a conta particular na rede Windows do DEMEC/UFPR.
4) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto o programa-fonte programa03.f90
5) Dentro do Fortran, editar exatamente o texto mostrado abaixo em vermelho, incluindo as linhas em branco.
INTEGER A, B, C, D, E, F, G
A
=
-6
B
=
2
C D
=
=
A + B -
B A

E = A * B F = A / B
G = A ** B
WRITE(*,*) "A = ", A WRITE(*,*) "B = ", B WRITE(*,*) "A + B = ", C WRITE(*,*) "B - A = ", D WRITE(*,*) "A * B = ", E WRITE(*,*) "A / B = ", F WRITE(*,*) "A ** B = ", G
END
a) A linha INTEGER A, B, C, D, E, F, G define as variáveis A, B, C, D, E, F e G como sendo do tipo inteiro. Este comando reserva espaço na memória do computador para diversas variáveis com apenas um comando INTEGER. Entretanto, as variáveis devem estar separadas por vírgula.
b) As linhas A = -6 e B = 2 atribuem os valores inteiros −6 e 2 às variáveis A e B. Estes valores são apenas exemplos; eles podem ser quaisquer números inteiros.
c) As variáveis C, D, E, F e G são calculadas em função dos valores das variáveis A e B, usando os cinco operadores matemáticos básicos definidos na Tabela 2.1, conforme explicado a seguir.
Tabela 2.1 Operadores matemáticos básicos em FORTRAN.
Símbolo do operador matemático em FORTRAN
Nome do símbolo
Operação matemática correspondente
+
Sinal mais
Adição
−
Sinal menos
Subtração
*
Asterisco
Multiplicação
/
Barra
Divisão
**
Duplo asterisco
Potenciação
d) A linha C = A + B adiciona os valores das variáveis A e B e atribui o resultado à variável C.
e) A linha D = B - A subtrai o valor da variável A do valor da variável B e atribui o resultado à variável D.
f) A linha E = A * B multiplica os valores das variáveis A e B e atribui o resultado à variável E.
g) A linha F = A / B divide o valor da variável A pelo valor da variável B e atribui o resultado à variável F.

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

11)Atribuir valores às variáveis dentro do próprio programa-fonte não é recomendável. Pois, para alterar os valores, é necessário ter o programa-fonte, além de recompilá-lo e gerar o programa-executável a cada vez. O procedimento mais indicado é utilizar o comando READ, apresentado na próxima seção.
2.7 programa03.f90, versão B
1) Dentro do Fortran, alterar o programa03.f90, versão A, para que fique exatamente igual ao texto mostrado abaixo em vermelho, incluindo as linhas em branco.
INTEGER A, B, C, D, E, F, G WRITE(*,*) "Entre com o valor de A"
READ(*,*) A
WRITE(*,*) "Entre com o valor de B" READ(*,*) B
C = A + B D = B - A E = A * B F = A / B
G = A ** B
WRITE(*,*) "A = ", A WRITE(*,*) "B = ", B WRITE(*,*) "A + B = ", C WRITE(*,*) "B - A = ", D WRITE(*,*) "A * B = ", E WRITE(*,*) "A / B = ", F WRITE(*,*) "A ** B = ", G
END
a) A única diferença entre a versão anterior (A) e a atual (B) do programa03.f90 está no ínicio do programa. É a inclusão de 4 linhas novas no lugar de se atribuir valores às variáveis A e B.
b) Até aqui, os comandos da linguagem FORTRAN que foram usados são: WRITE, END e INTEGER. Na versão B do programa03.f90, há um novo comando: READ. Ele é usado para atribuir (fornecer) valores às variáveis durante a execução de um programa. Isto é, o comando READ é empregado para LER os dados de um programa.

c) A linha WRITE(*,*) "Entre com o valor de A" escreve o comentário que está entre aspas.
d) A linha READ(*,*) A lê um valor digitado dentro da janela DOS, aberta durante a execução do programa, e o atribui à variável A.
5) Ao se executar o programa, através de Build, Execute, surge uma janela do tipo DOS dentro da qual tem-se:
a) Na primeira linha, o comentário Entre com o valor de A, resultado do comando WRITE(*,*) "Entre com o valor de A" do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o valor da variável A, resultado do comando READ(*,*) A do programa. Para que o programa continue sua execução é necessário digitar o valor −6 para a variável A e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o valor de B, resultado do comando WRITE(*,*) "Entre com o valor de B" do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o valor da variável B, resultado do comando READ(*,*) B do programa. Para que o programa continue sua execução é necessário digitar o valor 2 para a variável B e, em seguida, clicar na tecla enter.
e) Em seguida, são apresentados os mesmos resultados da versão A do programa03.f90, conforme a
Figura 2.9.
Figura 2.9 Resultado da execução do programa03.f90, versão B, com A = −6 e B = 2.
6) Executar novamente o programa, entrando com outros valores para A e B. Em seguida, analisar
cada resultado, comparando-o com o valor esperado obtido de um cálculo mental.
7) Executar novamente o programa, com A = 6 e B = 0. Nenhum resultado é apresentado porque o programa não consegue dividir 6 por 0. Isso gera um erro que interrompe a execução normal do programa. Ao se implementar um programa, deve-se prepará-lo para que seja evitado qualquer

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

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

Capítulo 3. Variáveis do tipo real 37
Capítulo 3. VARIÁVEIS DO TIPO REAL
Conceitos de: variáveis do tipo real, tradução de expressões algébricas em FORTRAN, mistura de variáveis do tipo inteiro com real, prioridade nas operações matemáticas
Operadores matemáticos básicos
Comando do FORTRAN: REAL
3.1 programa03c.f90
1) No Windows: Start, Programs, Fortran PowerStation 4.0, Microsoft Developer Studio
2) Neste capítulo será usado um projeto já existente, no caso o projeto do fim do capítulo 2. Para abri-lo, deve-se executar o seguinte no Fortran:
a) File, Open Workspace
b) Indicar o diretório do projeto chamado programa03
c) Selecionar o arquivo que tem o nome do projeto e extensão mdp, no caso programa03.mdp
d) Na subjanela do lado esquerdo do Fortran, clicar sobre o sinal + ao lado do nome do projeto;
deverá aparecer o nome do último programa-fonte que foi inserido neste projeto e) Clicar sobre o nome do programa-fonte
f) Edit, Cut para retirar o programa-fonte do projeto. Este comando não deletará o programa-fonte.
Ele apenas o retirará do projeto. Quando se quiser, ele poderá ser inserido no projeto novamente, bastando para isso selecionar o programa-fonte desejado dentro do seu diretório e usar o comando Insert, Files into Project.
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03c.f90
4) Conforme é mostrado na Figura 3.1, dentro do espaço de edição do Fortran, na subjanela maior,
copiar exatamente o texto em vermelho mostrado na Tabela 3.1.
a) Nos capítulos 1 e 2 foram usados os comandos WRITE, END, INTEGER e READ da linguagem FORTRAN. No programa03c.f90 há um novo comando: REAL. Ele é usado para definir variáveis do tipo real, isto é, variáveis que podem guardar ou armazenar na memória do computador

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

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

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

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

1) Nesta seção será usado um projeto já existente, no caso o projeto da seção anterior. Portanto, deve-se executar o seguinte no Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa03 o programa-fonte programa03e.f90
REAL A, B, C, D, E, F, G
Tabela 3.3 Programa03e.f90.
WRITE(*,*) Entre com o valor de A READ(*,*) A
WRITE(*,*) Entre com o valor de B READ(*,*) B
C = A + B D = B - A E = A * B F = A / B
G = A ** B
WRITE(*,*) A = , A WRITE(*,*) B = , B WRITE(*,*) A + B = , C WRITE(*,*) B - A = , D WRITE(*,*) A * B = , E WRITE(*,*) A / B = , F WRITE(*,*) A ** B = , G
END

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

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

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

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

REAL A, C, B, D
Tabela 3.6 Programa03f.f90.
REAL H1, H2, H3, H4, H5, H6, H7, H8, H9, H10, H11, H12
WRITE(*,*) Entre com os valores de A, C, B e D READ(*,*) A, C, B, D
H1 = A + B - C H2 = A + B / C
H3 = (A + B) / C
H4 = A + B / C * D
H5 = A + B / (C * D)
H6 = A + B * C ** D
H7 = A + (B * (C ** D)) H8 = 1.0 + 1.0E-10
H9 = C ** 3 ** 2
H10
=
(1.0
/
3 ) *
( (B**3)
**
(1
/
2.0)
)
H11
=
(1.0
/
3.0) *
( (B**3)
**
(1.0
/
2.0)
)
H12
=
(1
/
3 ) *
( (B**3)
**
(1
/
2 )
)
WRITE(*,*) H1 = , H1
WRITE(*,*) H2 = , H2
WRITE(*,*) H3 = , H3
WRITE(*,*) H4 = , H4
WRITE(*,*) H5 = , H5
WRITE(*,*) H6 = , H6
WRITE(*,*) H7 = , H7
WRITE(*,*) H8 = , H8
WRITE(*,*) H9 = , H9
WRITE(*,*) H10 = , H10
WRITE(*,*) H11 = , H11
WRITE(*,*) H12 = , H12
END

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

8) Analisar cada resultado mostrado na Figura 3.7 comparando-o com o valor esperado obtido de um cálculo mental ou com o uso de uma calculadora. Para tanto, devem ser consideradas a escala de prioridades da Tabela 3.4 e as regras descritas na Tabela 3.5.
9) Executar novamente o programa com outros valores para as variáveis A, C, B e D. Analisar cada novo resultado comparando-o com o valor esperado obtido de um cálculo mental ou com o uso de uma calculadora.
10) Para concluir o uso do Fortran e do Windows, deve-se executar os passos mostrados na seção 2.8 do capítulo 2.
3.6 EXERCÍCIOS
Exercício 3.1
Escrever as expressões em linguagem FORTRAN que correspondem às seguintes expressões algébricas, onde A, B e L são números reais e I e J são números inteiros:
Para verificar se a resposta de cada item está correta, basta implementar a expressão em FORTRAN num programa e comparar seu resultado com o valor obtido com uma calculadora para a expressão algébrica correspondente. Os dois resultados devem ser iguais. Isso também vale para o próximo exercício.

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

Capítulo 4. Variáveis do tipo caracter 50
Capítulo 4. VARIÁVEIS DO TIPO CARACTER
• Conceitos de: variáveis do tipo caracter, strings, funções intrínsecas
• Funções intrínsecas do FORTRAN para variáveis do tipo caracter: ADJUSTL, ADJUSTR, TRIM e
LEN
• Comando do FORTRAN: CHARACTER
4.1 programa4a.f90
1) No Windows: 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 programa04 no diretório Z:SERVER1Alunos2004_1login, onde login deve ser substituído pelo user name do usuário, isto é, a conta particular na rede Windows do DEMEC/UFPR.
3) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto o programa-fonte programa4a.f90
4) Conforme é mostrado na Figura 4.1, dentro do espaço de edição do Fortran, na subjanela maior,
copiar exatamente o texto em vermelho mostrado na Tabela 4.1.
a) Nos capítulos 1 a 3 foram usados os comandos WRITE, END, INTEGER, READ e REAL da linguagem FORTRAN. No programa4a.f90 há um novo comando: CHARACTER. Ele é usado para definir variáveis do tipo caracter ou string, isto é, variáveis que podem guardar ou armazenar comentários na memória do computador. Estes comentários podem incluir palavras, números, símbolos, espaços em branco ou frases. Alguns exemplos são (os conteúdos das variáveis estão separados por vírgula): UFPR, 5 de abril de 2004, teste de hoje, TM-102, U-20/5%, LL. As variáveis do tipo caracter também são chamadas de alfanuméricas porque envolvem letras e números.
b) No FORTRAN, o conteúdo ou string de uma variável do tipo caracter é definido entre aspas.
c) A linha CHARACTER A declara a variável A como sendo do tipo caracter. Este comando reserva um espaço na memória do computador, utilizando o nome ou rótulo A, para armazenar um único

caracter alfanumérico.
d) A linha A = UFPR, Curitiba, PR atribui o conteúdo entre aspas à variável A.
CHARACTER A
A = UFPR, Curitiba, PR
Tabela 4.1 Programa4a.f90, versão 1.
WRITE(*,*) Conteudo de A = , A
END
Figura 4.1 Programa4a.f90, versão 1.
a) Na primeira linha, o comentário Conteudo de A =, e, em seguida, a letra U, resultado do comando
WRITE(*,*) Conteudo de A = , A do programa.
b) Na segunda linha, a frase Press any key to continue. Como diz este aviso, basta clicar em qualquer tecla para continuar. Ao se fazer isso, a execução do programa é encerrada.

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

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

Figura 4.4 Resultado da execução do programa4b.f90.
8) Executar novamente o programa, através de Build, Execute, testando outros conteúdos para a variável A e vendo o resultado. Testar, por exemplo, uma frase com pelo menos duas palavras mas sem usar aspas para definir o conteúdo de A.
4.3 programa4c.f90
1) Nesta seção será usado o mesmo projeto da seção anterior. Portanto, deve-se executar o seguinte no
Fortran:
2) No Fortran, seguindo o procedimento apresentado na seção 1.7 do capítulo 1, criar e inserir no projeto chamado programa04 o programa-fonte programa4c.f90
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
Tabela 4.4 Programa4c.f90.
WRITE(*,*) Entre com o local = READ(*,*) LOCAL
WRITE(*,*) Entre com o dia = READ(*,*) DIA
WRITE(*,*) Entre com a hora = READ(*,*) HORA
FRASE = Frase: // LOCAL // , // DIA // , as // HORA // horas WRITE(*,*) Conteudo de FRASE = , FRASE
END
a) Na primeira linha, o comentário Entre com o local =, resultado do comando WRITE(*,*) Entre com o local = do programa.
b) Na segunda linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável LOCAL, resultado do comando READ(*,*) LOCAL do programa. Para que o programa continue sua execução é necessário digitar o conteúdo da variável LOCAL, por exemplo, “Curitiba” e, em seguida, clicar na tecla enter.
c) Na terceira linha, o comentário Entre com o dia =, resultado do comando WRITE(*,*) Entre com o dia = do programa.
d) Na quarta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável DIA, resultado do comando READ(*,*) DIA do programa. Para que o programa continue sua execução é necessário digitar o conteúdo da variável DIA, por exemplo, “5 de abril de 2004” e, em seguida, clicar na tecla enter.
e) Na quinta linha, o comentário Entre com a hora =, resultado do comando WRITE(*,*) Entre com a hora = do programa.
f) Na sexta linha, o programa pára e fica aguardando que seja fornecido o conteúdo da variável
HORA, resultado do comando READ(*,*) HORA do programa. Para que o programa continue sua

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

CHARACTER(9) A INTEGER L
Tabela 4.5 Programa4d.f90.
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.

Fortran90 index

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (18)

En vedette

En vedette (15)

Similaire à Fortran90 index

Similaire à Fortran90 index (20)

Dernier

Dernier (20)

Fortran90 index