Livrof90 V8-Preliminar1 PDF

livrof90_v8-preliminar1 2014/5/5 1:07 page i #1
Srie Linguagem de Programao Cientfica
Fortran 95:
curso bsico
Gilberto Orengo
Professor adjunto do Curso de Fsica Mdica
Centro Universitrio FranciscanoUNIFRA
http://www.orengonline.com/
orengo@orengonline.com
1Edio
Editora XXX
livrof90_v8-preliminar1 2014/5/5 1:07 page ii #2
Copyright2007 de Gilberto Orengo

Copyright dos Apndices 2007 de Gilberto Orengo
Capa
Lucas Rodrigues dos Santos
Preparao e digitao no LATEX
Gilberto Orengo
Ilustraes no texto
Gilberto Orengo e Lucas Rodrigues dos Santos
Reviso
CCCC DDDD HHHH
Impresso
Grfica ZZZZZZZZ
(55) xxxx.xxxx
Santa MariaRS
Site do Livro
http://www.orengonline.com/fortran95/
Dados Internacionais de Catalogao na Publicao (CIP)

Cmara Brasileira do Livro, SP, Brasil
Orengo, Gilberto, 1961
Fortran 95: curso bsico / Gilberto Orengo. Santa Maria:
Editora da UNIFRA, 2007.
ISBN: XX-XXXX-XXX-X
1. Informtica 2. Fortran 3. Linguagem de Programao
YY-XXXX
Arquivo LATEX original: livrof90_v5.tex
ndices para catlogo sistemtico:

1. Linguagem de programao
2. Fortran 90/95
[2007]
Espao reservado Editora
Todos os direitos desta edio reservados ..
CDD-ZZZ.ZZ
livrof90_v8-preliminar1 2014/5/5 1:07 page iii #3
SUMRIO
Apresentao
vii
Prefcio
1
CONSIDERAES INICIAIS: Apresentando o Fortran

1.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . .
O Livro . . . . . . . . . . . . . . . . . . . . . . .
Um Breve Histrico sobre o Fortran . . . . . . .
1.2 Os bits e bytes . . . . . . . . . . . . . . . . . . . . . .
1.3 Como Trabalha a Memria do Computador? . . . .
Compilador . . . . . . . . . . . . . . . . . . . . . . .
Interpretador . . . . . . . . . . . . . . . . . . . . . .
Depurador . . . . . . . . . . . . . . . . . . . . . . . .
1.4 As Unidades de Programa . . . . . . . . . . . . . . .
O Programa Principal (Main Program) . . . . . . . .
O Formato livre . . . . . . . . . . . . . . . . . .
O Conjunto de Caracteres . . . . . . . . . . . . .
Os Nomes Simblicos em Fortran . . . . . . . .
Os Rtulos em Fortran . . . . . . . . . . . . . .
O Primeiro Programa . . . . . . . . . . . . . . . . . .
O Segundo Programa . . . . . . . . . . . . . . . . . .
1.5 A Despensa de Dados no Fortran 95 . . . . . . . .
1.5.1 Dados Inteiros - INTEGER (Preciso Simples)
1.5.2 Dados Reais ou de Pontos Flutuantes - REAL
Preciso Simples (Single Precision) . . . . .
Preciso Dupla (Double Precision) . . . . .
1.5.3 Os Nmeros Complexos - COMPLEX . . . . .
1.5.4 Os outros dados: LOGICAL e CHARACTER . .
1.6 A Declarao das Variveis . . . . . . . . . . . . . .
A Atribuio de valor varivel . . . . . . . . . .
A inicializao de variveis . . . . . . . . . . . . .
Variveis globais e locais . . . . . . . . . . . . . .
1.7 Os Procedimentos Intrnsecos . . . . . . . . . . . . .
1.7.1 As Funes Matemticas Intrnsecas . . . . .
ix
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
4
7
9
10
12
12
13
13
14
14
15
16
16
18
22
22
22
23
23
24
24
25
26
26
27
30
30
livrof90_v8-preliminar1 2014/5/5 1:07 page iv #4
iv
SUMRIO
1.7.2 A Aritmtica com inteiros e reais . .

As Expresses Aritmticas . . . . . . . .
A Aritmtica dos inteiros . . . . . . . . .
A Aritmtica dos reais . . . . . . . . . . .
A Aritmtica mista: entre inteiros e reais
1.7.3 A Manipulao de Caracteres . . . .
1.8 Corrigindo Erros DEBUGGING . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
32
32
33
34
34
35
38
45
TRABALHANDO COM ARQUIVOS ENTRADAS/SADAS (I/O) DE DADOS

2.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 A instruo WRITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 A instruo READ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 A instruo OPEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5 A instruo CLOSE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.6 Formatando as sadas e/ou entradas (FORMAT) . . . . . . . . . . . . . . .
2.7 Corrigindo Erros DEBUGGING . . . . . . . . . . . . . . . . . . . . . . .
Entrada de dados em uma nica linha de um arquivo . . . . . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
49
49
50
50
51
53
54
56
60
60
62
AS ESTRUTURAS DE CONTROLE
3.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 Expresses Aritmticas . . . . . . . . . . . . . . . . . . . . . . . .
3.1.2 Expresses Lgicas . . . . . . . . . . . . . . . . . . . . . . . . . . .
Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . .
Operadores Lgicos . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.3 Hierarquia dos Operadores . . . . . . . . . . . . . . . . . . . . . .
3.2 Estruturas com Deciso (ou Seleo) . . . . . . . . . . . . . . . . . . . . .
3.2.1 Estrutura Condicional Simples (IF...THEN) . . . . . . . . . . .
3.2.2 Estrutura Condicional Composta (IF...THEN...ELSE IF) .
3.2.3 A instruo IF Lgico . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.4 A estrutura de seleo direta (SELECT CASE...CASE) . . . . . .
3.3 Estruturas de Repetio (Loops) . . . . . . . . . . . . . . . . . . . . . . . .
3.3.1 A Estrutura de repetio DO...END DO . . . . . . . . . . . . . . .
3.3.2 A Estrutura de repetio DO...IF...END DO ou DO infinito . .
O uso do WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
63
63
64
65
65
65
67
67
67
69
71
71
73
73
74
76
77
AS VARIVEIS COMPOSTAS Arranjos

4.1 Introduo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Os Vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 A declarao de um vetor . . . . . . . . . . . . . . . . .
4.2.2 Preenchendo com valores os elementos de um vetor . .
4.2.3 A manipulao dos elementos de um vetor . . . . . . .
4.3 As Matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 A declarao de uma matriz . . . . . . . . . . . . . . . .
4.3.2 Preenchendo com valores os elementos de uma matriz
4.3.3 A manipulao dos elementos de uma matriz . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
79
79
80
80
82
83
84
85
85
86
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
livrof90_v8-preliminar1 2014/5/5 1:07 page v #5
Fortran 95: curso bsico (Gilberto Orengo)
Exerccios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5
A ALOCAO DINMICA DE MEMRIA (ALLOCATABLE)

91
5.1 O Atributo ALLOCATABLE e as Declaraes ALLOCATE e DEALLOCATE . . . . . 92
5.2 Quando Devemos Usar uma Array? . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.3 Manipulao entre Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
AS SUB-ROTINAS E FUNES
6.1 Introduo . . . . . . . . . . . . . . . . .
Procedimentos Externos . . . . . .
Procedimentos Internos . . . . . . .
6.2 As Sub-rotinas SUBROUTINE . . . . .
6.3 As Funes FUNCTION . . . . . . . . .
6.4 As Bibliotecas de Sub-rotinas e Funes
6.4.1 A biblioteca LAPACK . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
97
97
97
98
99
101
103
103
AS FUNES INTRNSECAS SELECTED_REAL_KIND E SELECTED_INT_KIND 107

7.1 Selecionando Preciso de Maneira Independente do Processador . . . . . . . . 109
OS PROCEDIMENTOS MODULE
8.1 A Declarao COMMON . . . . . . . . . . . . . . . . . . . .
8.2 A Declarao MODULE . . . . . . . . . . . . . . . . . . . .
8.2.1 Compartilhando Dados usando o MODULE . . . .
8.3 Os Procedimentos MODULE . . . . . . . . . . . . . . . . . .
8.3.1 Usando Mdulos para Criar Interfaces Explcitas
8.3.2 A Acessibilidade PUBLIC e PRIVATE . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
111
111
113
113
114
115
116
Apndices:
118
A A Tabela ASCII de Caracteres
119
B Os tipos de Dados Intrnsecos suportados pelo Fortran 95
121
C Glossrio
123
D Como Abordar um Problema de Programao

D.1 Analise o problema (e projete seu programa) antes de program-lo . .
D.2 Escreva um cdigo legvel . . . . . . . . . . . . . . . . . . . . . . . . . .
D.2.1 Comente seu cdigo enquanto escreve, no depois . . . . . . .
D.2.2 Utilize margens e indentao apropriadamente . . . . . . . . .
D.2.3 Use nomes sugestivos para variveis, funes e procedimentos
D.2.4 Utilize funes e procedimentos curtos e objetivos . . . . . . . .
D.3 Se estiver confuso na hora da depurao . . . . . . . . . . . . . . . . . .
D.4 Guia prtico para resoluo de problemas de programao . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
125
125
125
126
126
126
126
127
127
E O LATEX e este Livro

E.1 Sobre o texto . . . . . . . . . . . .
E.2 A definio dos tons de cinza . .
E.3 A nota de margem . . . . . . . .
E.4 As notas de observaes no texto
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
129
129
130
131
131
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
livrof90_v8-preliminar1 2014/5/5 1:07 page vi #6
vi
SUMRIO
E.5
E.6
E.7
E.8
Os quadros das Instrues Fortran 95

Os exemplos de programas Fortran 95
Os mini-sumrios dos Captulos . . .
As Referncias Bibliogrficas . . . . .
Referncias Bibliogrficas
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
132
133
134
134
135
livrof90_v8-preliminar1 2014/5/5 1:07 page vii #7
vii
livrof90_v8-preliminar1 2014/5/5 1:07 page vii #8
Apresentao
Nesta parte ser transcrito os textos de apresentao de dois pesquisadores da rea de Fsica
e de Matemtica, usurios ativos e seniors do Fortran.
livrof90_v8-preliminar1 2014/5/5 1:07 page viii #9
livrof90_v8-preliminar1 2014/5/5 1:07 page ix #10
Prefcio
(Texto provisrio) Este livro o resultado de um longo perodo de contato com a linguagem
Fortran. Tudo comeou na graduao do Curso de Fsica, na Universidade Federal de Santa
Maria-RS (UFSM), entre 1984 e 1989, passou pelo Mestrado em Fsica Aplicada/UFSM, com
o auxlio fundamental dos professores Cludio de Oliveira Graa/UFSM e Manoel Siqueira,
da Universidade Federal de Minas Gerais (UFMG). No doutorado em Engenharia Nuclear,
pela Universidade Federal do Rio Grande do Sul (UFRGS) o passo final, em que parte da tese
foi a construo de uma verso inicial de um cdigo computacional, sob tutela do professor
Marco Tulio M. B. de Vilhena/UFRGS. Tambm contriburam o curso ministrado na UFRGS,
para alunos da Engenharia Mecnica ao lado da professora Cynthia Segatto e, a construo
de um material didtico para um Minicurso de Fortran 90/95, para a Semana Acadmica do
Curso de Fsica Mdica do Centro Universitrio Franciscano (UNIFRA), em junho de 2001.
Uma forte contribuio tambm venho das aulas da disciplina Linguagem de Programao
Cientfica para o Curso de Fsica Mdica/UNIFRA, desde 2002.
A minha formao em Fortran foi baseada principalmente no aprendizado autodidata.
Todos os livros citados nas referncias tiveram influncia sobre a minha viso a respeito da
linguagem Fortran e na forma de programar. Portanto, algumas caractersticas deles foram
incorporadas, subconscientemente, e podem fazer parte do meu texto. Um destes livros que
considero uma referncia o Professional Programmers Guide to Fortran77, de Clive G. Page da
University of Leicester, UK, 1995.
A diferena entre o Fortran 90 e o 95 sutil. No Fortran 95 foram realizadas pequenas correes do Fortran 90 e introduzidas algumas facilidades de programao paralela,
como por exemplo, o procedimento FORALL. A escolha do ttulo do livro foi pelo Fortran 95,
embora no trataremos neste texto a respeito dos avanos do Fortran 95, que far parte da
sequncia do livro, numa edio mais avanada. Este livro tem um perfil introdutrio e
veremos os conceitos mnimos necessrios para uma iniciao na linguagem Fortran, introduzindo alguns conceitos mais modernos do Fortran 90/95.
Este livro foi pensado para ser usado por estudantes que no conhecem a linguagem
Fortran, bem como por aqueles que j dominam a linguagem. Os programadores que tiveram
contato com o antigo e bom FORTRAN 77 tero neste livro uma atualizao especialmente
nos ltimos quatro captulos. aconselhvel para os iniciantes que leiam os captulos na
sequncia em que so apresentados. J os conhecedores da linguagem podem saltear entre
livrof90_v8-preliminar1 2014/5/5 1:07 page x #11
SUMRIO
os captulos, conforme a necessidade, mas sugerido que leiam o primeiro captulo, para
entenderem algumas peculiaridades da escrita do livro.
Na pgina oficial do livro estaro disponveis atualizaes, correes, novidades, exerccios e problemas. Costumo evidenciar que em programao h uma diferena entre exerccios e problemas, ou entre a soluo de problemas e prtica com exerccios. O primeiro subentende
que o segundo foi realizado exaustivamente e, assim, estaremos, em princpio, habilitados
para resolver ou solucionar problemas. O endereo da pgina :
http://www.orengonline.com/fortran95/
Tambm esto disponveis as respostas e comentrios a respeito dos exerccios do livro, no
item exerccios. E, para verificar se est pronto para resolver problemas, um conjunto deles
est disponvel no item problemas.
METODOLOGIA ...
Nos exemplos de programas as instrues da linguagem Fortran sero destacadas em
negrito, e os elementos que no fazem parte da parte da sintaxe da linguagem sero escritos
sem negrito. Mas, no texto, para chamar ateno sero tambm destacados em negrito.
Gilberto Orengo
Santa Maria, 2007
livrof90_v8-preliminar1 2014/5/5 1:07 page 1 #12
CAPITULO
CONSIDERAES INICIAIS:
Apresentando o Fortran
Neste captulo voc encontrar:
1.1 Introduo . . . . . . . . . . . . . . . . . .
O Livro . . . . . . . . . . . . . . . . .
Um Breve Histrico sobre o Fortran . . .
1.2 Os bits e bytes . . . . . . . . . . . . . . .
1.3 Como Trabalha a Memria do Computador? .
Compilador . . . . . . . . . . . . . . . . .
Interpretador . . . . . . . . . . . . . . . .
Depurador . . . . . . . . . . . . . . . . . .
1.4 As Unidades de Programa . . . . . . . . . .
O Programa Principal (Main Program) . . . .
O Formato livre . . . . . . . . . . . . .
O Conjunto de Caracteres . . . . . . .
Os Nomes Simblicos em Fortran . . .
Os Rtulos em Fortran . . . . . . . . .
O Primeiro Programa . . . . . . . . . . . .
O Segundo Programa . . . . . . . . . . . .
1.5 A Despensa de Dados no Fortran 95 . . .
1.5.1 Dados Inteiros - INTEGER (Preciso
Simples) . . . . . . . . . . . . . . .
1
2
3
6
9
10
11
11
12
12
13
13
14
14
15
17
20
21
1.5.2 Dados Reais - REAL . . . . . . . . .

Preciso Simples (Single Precision)
Preciso Dupla (Double Precision) .
1.5.3 Os Nmeros Complexos - COMPLEX .
1.5.4 Os dados: LOGICAL e CHARACTER .
1.6 A Declarao das Variveis . . . . . . . . .
A Atribuio de valor varivel . . . . . .
A inicializao de variveis . . . . . . . .
Variveis globais e locais . . . . . . . . .
1.7 Os Procedimentos Intrnsecos . . . . . . . .
1.7.1 As Funes Matemticas Intrnsecas
1.7.2 A Aritmtica com inteiros e reais . . .
As Expresses Aritmticas . . . . . . . .
A Aritmtica dos inteiros . . . . . . . . .
A Aritmtica dos reais . . . . . . . . . . .
A Aritmtica mista: entre inteiros e reais .
1.7.3 A Manipulao de Caracteres . . . .
1.8 Corrigindo Erros DEBUGGING . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . .
21
21
22
22
23
23
24
25
25
29
29
31
31
32
32
33
34
37
44
1.1
INTRODUO
Seja bem-vindo ao universo Fortran.
Neste incio de conversa importante salientar que este texto foi integralmente escrito com o
LATEX [1][5]. O LATEX um sistema de processamento de textos utilizado especialmente para
produzir documentos cientficos de alta qualidade tipogrfica. tambm til para outros
tipos de documentos, desde simples cartas at livros completos. O LATEX utiliza o TEX como
base para seu processamento e a sua distribuio gratuita, disponvel para a maioria dos
sistemas operacionais como o UNIX, Linux, Windows, OSMac, Sun e VMS. Nas Universidades encontrado, previamente instalado, nas redes UNIX/Linux de computadores (exceto
redes Windows). aconselhvel, se voc ainda no teve contato com LATEX que o faa.
uma ferramenta computacional muito poderosa para uso no meio acadmico e cientfico. No
Apndice E so apresentadas algumas linhas de programao LATEX, que foram utilizadas na
elaborao deste livro.
CAPTULO 1. CONSIDERAES INICIAIS: Apresentando o Fortran
O LIVRO
muito importante para compreenso na leitura do livro observar as seguintes convenes
adotadas.
NOTAO DO LIVRO
As seguintes notaes ou convenes so usadas ao longo do livro:
fortran
95
na linha que aparece este smbolo, como nota de margem, ser destacado na
mesma cor a instruo referente ao Fortran 95, que no havia no FORTRAN 77.
fundo cinza claro conter um exemplo de programa Fortran 95. A numerao dos
programas seguir sequencialmente na ordem arbica, antecedida do nmero do
captulo.
fundo cinza mdio conter a sintaxe de instrues ou procedimentos do Fortran 95.
fortran
95
fortran
95
AaBb
escritas com o tipo typewriter negrito identificaro elementos referentes ao

Fortran 95.
AaBb
escritas com o tipo helvtica negrito identificaro exemplos referentes ao LATEX,

disponveis no Apndice E.
os colchetes sempre indicaro que o elemento Fortran 95 opcional, por exemplo,

uma declarao, uma instruo ou um atributo.
[Nx]
em sobrescrito identifica uma nota de rodap, em que x ser o nmero da nota.
notas como esta, em fonte helvtica, permitiro inseres informativas, ou

explicativas ou ainda de advertncias a respeito da programaao em linguagem
Fortran.
O contedo sobre Fortran [6][10] extenso para ser tratado num livro que pretende
ser introdutrio. Sendo assim, veremos os conceitos mnimos necessrios para uma iniciao na linguagem Fortran e, na sequncia introduziremos alguns conceitos mais modernos
do Fortran 90/95, o qual chamaremos somente de Fortran 95. Entre as evolues sofridas pelo Fortran (relativas ao FORTRAN 77) daremos nfase a trs: as funes intrnsecas
SELECTED_REAL_KIND e SELECTED_INT_KIND (Cap. 7, na pg. 107), que permitem maior
portabilidade entre computadores e compiladores Fortran; a declarao de variveis ALLOCATABLE (Cap. 5, na pg. 91), que habilita a alocao dinmica de memria e; as Declaraes
e Procedimentos do tipo MODULE (no Cap. 8, na pg. 111) que, entre outras funes, substitui
com primazia os confusos e perigosos COMMON, que so utilizados como uma declarao para
compartilhar uma mesma rea de memria entre duas ou mais unidades de programa, e para
especificar os nomes das variveis que devem ocupar esta rea comum. A rea de memria
suportada pelo COMMON pode ser entendida como uma seqncia de posies na memria
principal. Este assunto ser apresentado no Captulo 8.
Sutilmente ao longo do texto sero apresentados outros pequenos avanos da linguagem, sempre destacados pela conveno acima descrita.
As atualizaes do Fortran 95 como o uso de ponteiros (POINTER) ou, os tipos de dados definidos pelo usurio (TYPE), entre outras, sero tratadas em outra oportunidade. Elas
faro parte da sequncia deste livro, que tratar de questes mais avanadas relativas ao
Fortran 95. Abordagens mais completas a respeito do Fortran podem ser encontradas nos
livros citados nas referncias bibliogrficas. Mas importante ter em mente que ao usarem
um compilador[N1] Fortran, uma valiosa fonte de informao encontra-se no Guia (ou Manual) do Usurio (Users Guide) e no Manual de Referncia da Linguagem (Language Reference
Manual) do referido compilador.
Ser utilizado, como referncia, o compilador Fortran G95 desenvolvido, sob a licena
GNU[N2] , pela comunidade de Software Livre e pode ser obtido gratuitamente no site
http://www.g95.org, para diferentes plataformas e sistemas operacionais. No Apndice ??
apresentado, detalhamente, como obter, instalar e utilizar o compilador Fortran G95, tanto
para o sistema operacional Windows como para o Linux e, uma lista de compiladores Fortran
descrita no Apndice ??.
As aplicaes da linguagem ficaro restridas as reas da Fsica, da Matemtica e das Engenharias, embora o Fortran possa ser aplicado a outras reas como por exemplo Economia,
Administrao, Informtica e Biologia.
Este livro poder ser usado por estudantes que no conhecem a linguagem Fortran, bem
como por aqueles que j dominam a linguagem, especialmente se forem oriundos do antigo
e bom FORTRAN 77. Para os iniciantes aconselhvel que leiam (estudem) os captulos na
sequncia em que se encontram. Os conhecedores da linguagem podem saltear entre os captulos, conforme a necessidade, mas interessante que leiam este captulo, para entenderem
algumas peculiaridades da escrita do livro.
Um glossrio, disponvel no Apndice C (pg. 123), conter explicaes e definies
rpidas sobre conceitos ou elementos do Fortran 95. Assim, contribuir para uma viso mais
global a respeito da linguagem.
No Apndice ??, na pgina ??, traz um resumo dos captulos, cujo objetivo o de um
Guia de Referncia, de rpido e fcil acesso. A disposio do resumo dos captulos em um
nico local, por acreditar que esta metodologia contribua mais para o aprendizado e seja
mais didtica do que o resumo no final de cada captulo.
[N1] O termo compilador se refere, no jargo da informtica, a um software que faz a traduo de um programa fonte
codificado em um cdigo legvel para a mquina. Estudaremos o compilador na pgina 10.
[N2] Informaes a respeito da licena GNU podem ser obtidas em http://www.fsf.org/.
fortran
95
UM BREVE HISTRICO SOBRE O FORTRAN

Para muitos, nos anos 80, o Fortran estava morto e sepultado, porque a sintaxe da linguagem foi e, at os dias atuais, considerada arcaica por muitos programadores que aprenderam linguagens mais modernas.
O Fortran uma linguagem de computador para programao tcnica e cientfica, a qual
foi criada sob medida para execuo eficiente em uma vasta variedade de processadores.
A primeira padronizao ocorreu 1966, e desde ento foram realizadas trs revises (1978,
1991 e 1997). A reviso de 1991 foi a maior das trs. Uma quarta reviso foi implementada
em acordo com o Encontro da ISO/IEC JTC1/SC22/WG5 em 1997, que considerou todas as
sugestes e pedidos dos usurios da linguagem, culminando no Fortran 2003.
Os avanos significativos da reviso de 1991 foram a alocao dinmica de memria,
tipos derivados de dados, manipulao de arranjos (p.ex., matrizes e vetores), mdulos, ponteiros, tipos de dados parametrizados e estruturas. Mas o principal impulso dado na linguagem foi em relao as caractersticas do HPF (High Performance Fortran). A seguir veremos
uma breve retrospectiva e os avanos propostos pelo Fortran 2003.
A linguagem Fortran a matriz de todas as linguagens cientficas de computadores. No
comeo tinha somente a inteno de traduzir equaes cientficas para cdigos de computadores e, foi neste sentido um programa verdadeiramente revolucionrio. Antes do Fortran
todos os programas de computadores eram lentos e originavam muitos erros. Na primeira
verso, o FORTRAN I, lanada entre 1954 e 1957, a linguagem era muito pequena em comparao com as verses mais modernas. Entre outras coisas, continha somente as declaraes
de variveis para os tipo inteiro (INTEGER) e real (REAL) e tambm no havia sub-rotinas.
Durante este perodo percebeu-se diversos erros, que foraram a IBM lanar o FORTRAN II
em 1958.
Um avano ocorreu com o lanamento da verso FORTRAN IV, em 1962, que permitiu
os cientistas utilizarem pelos prximos 15 anos. Com isso, em 1966 o Fortran adotou uma
padronizao, a American National Standards Institute Instituto Nacional Americano de Padronizao(ANSI) e passou a ser chamado de FORTRAN 66.
A partir desta verso, todas as atualizaes seguiram um padro e o outro avano veio
com o FORTRAN 77, em 1977. Entre as novas caractersticas esto as que permitiram escrever e armazenar mais facilmente programas estruturados. Nesta verso foram introduzidas
novas estruturas, como o bloco de deciso lgica IF...THEN e foi a primeira verso que
habilitou o manuseio amigvel de variveis tipo caracteres (CHARACTER) ou strings.
A atualizao mais importante foi a que deu origem ao Fortran 90. Esta verso inclui
todo o FORTRAN 77 que serve de base, mas com mudanas significativas, tais como: i) a
implementao da alocao dinmica de memria para os arranjos (ou, em ingls, arrays
vetores e matrizes); ii) mudanas nas operaes com arrays; iii) a parametrizao das funes
intrnsecas, permitindo assim utilizar mais do que dois tipos de preciso (simples e dupla)
para variveis do tipo real e complexa; iv) capacidade de escrever procedimentos internos
e recursivos, como tambm chamar os procedimentos atravs de argumentos, sendo estes,
opcionais ou obrigatrios; v) a implementao do conceito de ponteiros; vi) melhor portabilidade entre compiladores e processadores; vii) o uso de caractersticas especiais do hardware,
tais como: cache de instrues, pipeline[N3] da CPU, disposies de programao paralela (ve[N3] pipeline:
arquitetura de computador em pipeline (encadeada); 1. CPUUnidade Central de Processamento que
torizao), entre outras.

Estes novos conceitos da linguagem fizeram do Fortran 90 uma linguagem mais eficiente, especialmente para a nova gerao de supercomputadores, e que nos permite dizer: a
linguagem Fortran continuar a ser usada com sucesso por muito tempo. Embora o Fortran
no seja muito utilizado fora dos campos da Cincia da Computao e da anlise numrica,
permanece como uma linguagem que desempenhar tarefas da rea da computao numrica de alto rendimento. Neste sentido, o Fortran at hoje superior em relao aos seus
competidores, em especial em aplicaes cientficas computacionalmente intensivas como
Fsica, Matemtica, Meteorologia, Astronomia, Geofsica e Engenharias, porque permite a
criao de programas que primam pela velocidade de execuo.
O padro mais recente, o Fortran 2003, sofreu a maior reviso, introduzindo vrias novas caracterticas. Esta atualizao contempla, entre outros, os seguintes avanos:
acrscimos de tipos de dados definidos pelo usurio: tipos de dados parametrizados, aperfeioamento no controle de acessibilidade e de estrutura. Por exemplo, definir o KIND
somente na utilizao efetiva do tipo definido e no antes;
suporte a programao Orientada a Objetos: herana e extenses, poliformismo, alocao

dinmica de tipos de dados e, finalizaes, cujo objetivo limpar (desalocar) a memria de ponteiros quando deixam de existir.
manipulao otimizada de dados: entre outras, a alocao de componentes; o atributo

VOLATILE, o qual indicar que o dado objeto poder sofrer alterao ao longo da execuo, mesmo por outro programa que esteja rodando em paralelo; transferncia de
alocaes de memria, e acrscimos nos procedimentos intrnsecos.
avanos nas Entradas/Sadas: operaes de transferncia definidas pelo usurio para dados definidos pelo usurio; controle nas converses de formatos; constantes nominativas para unidade lgicas pr-conectadas, acesso as mensagens de erro; instruo
FLUSH, que permitar, entre outras coias, ler via teclado caracter por caracter, e tambm tornar disponvel o dado para outro processo. Entrada/Sada assincrna, que
permitir qie outras instrues podem ser executadas enquanto uma instruo de Entrada/Sada (leitura/escrita) est em execuo.
procedimento ponteiros;
suporte para as excees do padro para pontos flutuantes (IEEE 1989);
mais interoperabilidade com a linguagem C: permitindo, por exemplo, acesso a bibliotecas

de baixo nvel da linguagem C e vice-versa, ou seja, bibliotecas escritas em Fortran
podem ser acessadas pela linguagem C.
suporte ao conjunto de caracteres internacionais: acesso aos caracteres ISO 10646 (2000) 4byte, que suficiente para cobrir todas as linguagens escritas do mundo. E, a escolha
construda em blocos e executa instrues em passos em que cada bloco trata de uma parte da instruo e dessa
forma acelera a execuo do programa; 2. (a) escalar a chegada das entradas no microprocessador quando nada mais
est acontecendo e desta forma aumentando a velocidade aparente de processamento; (b) iniciar o processamento
de uma segunda instruo enquanto a atual ainda est processando de forma a aumentar a velocidade de execuo
de um programa. Fonte: DIC Michaelis UOL, distribuio gratuita em CDROM.
pelo usurio por ponto ou vrgula para dados numricos formatados de Entradas/Sadas. Uma nova funo intrnseca, para caracteres, a qual retorna o tipo de conjunto de
caracteres: SELECTED_CHAR_KIND(NAME);
integrao com sistemas operacionais: que permitir acessar os argumentos na linha de

comando e a variveis de ambiente do interpretador, bem como as mensagens de erros
do processador.
O compilador G95, que ser utilizado nos exemplos deste livro, j contm as caractersticas implantadas no Fortran 2003. Para um conhecimento mais abrangente a respeito desta
atualizao do Fortran aconselha-se a referncia [11], da qual foram extradas as informaes
descritas acima.
No Fortran 2008 ser revisado o Fortran 2003. Como ocorreu com o Fortran 95 em relao ao Fortran 90, ser uma pequena evoluo, somente incluindo correes e esclarecimentos do Fortran 2003. Mas ser nesta verso a implementao mais efetiva na manipulao de
processamento paralelo e os tipos de dados BIT.
A linguagem Fortran definida de acordo com o Padro Internacional ISO/IEC 1539.
Atualmente, os padres que conduzem as implementaes do Fortran so:
ANSI X3.198-1992 (R1997). Ttulo: Programming Language Fortran Extended. informalmente conhecida como Fortran 90. O padro publicado pela ANSI.
ISO/IEC 1539-1:1997. Ttulo: Information technology - Programming languages - Fortran Part 1: Base language. informalmente conhecido como Fortran 95. Existem mais duas
partes deste padro. A Parte 1 foi formalmente adotada pelo ANSI.
ISO/IEC 1539-2:2000. Ttulo: Part 2: Varying length strings. Descreve um conjunto de

procedimentos adicionais que fornecem formas de strings conterem comprimentos variveis.
ISO/IEC 1539-3:1998. Ttulo: Part 3: Conditional compilation. Descreve um conjunto de

recursos adicionais que podem ser utilizados em opes de compilao.
Estas informaes, bem como notcias a respeito das atualizaes, podem ser visualizadas no endereo: http://www.nag.co.uk/sc22wg5/IS1539_family.html.
Est disponvel no endereo http://www.orengonline.com/fortran95/ uma transcrio de
uma reportagem do New York Times, de 13 de junho de 2001, a respeito dos criadores do
Fortran. O ttulo Pioneers of the Fortran Programming Language.
A seguir estudaremos termos cujos significados sero importantes em todo o livro. Veremos tambm os conceitos relacionados a estrutura de um programa Fortran, tais como os
tipos e a declarao de dados. E, criaremos passo-a-passo um programa Fortran, decrevendo
e explanando cada etapa.
1.2
OS BITS E BYTES
Para uma aprendizagem mais significativa necessrio e importante conhecermos alguns
termos utilizados nesta rea da computao. Um ponto forte no uso de computadores a
memria. As memrias dos computadores so compostas de milhes de interruptores eletrnicos individuais, cada um assumindo ON ou OFF (ligado ou desligado), nunca num
estado intermedirio. Cada um dos interruptores representa um dgito binrio (tambm
conhecido como bit de binary digit), em que o estado ON interpretado como o binrio
1 e o estado OFF como o binrio 0. Diversos bits agrupados representam o sistema binrio de nmeros ou simplesmente sistema de base dois, representado pelo conjunto {0,1}. Para
comparao, a base do sistema decimal 10 (0 a 9).
O nmero de arranjos possveis para nmeros binrios fornecido por 2n , em que n
o nmero de opes possveis. O menor agrupamento de bits chamado de Byte. Um Byte
consiste de um grupo de 8 bits e a unidade fundamental usada para medir a capacidade da
memria de um computador. A partir desta unidade fundamental temos:
1024 Bytes = 1 KByte (1 KiloByte ou 1 KB), devido a base dois temos: 210 = 1024.
1024 KBytes = 1 MByte (1 MegaByte ou 1 MB = 220 = 1048576 Bytes).
1024 MBytes = 1 GByte (1 GigaByte ou 1 GB = 230 Bytes).
1024 Gbytes = 1 TByte (1 TeraByte ou 1 TB = 240 Bytes).
Para compreendermos um pouco mais o sistema binrio busquemos algo familiar, o
nosso sistema decimal, ou sistema de base 10, representado pelo conjunto {0, 1, 2, 3, 4, 5, 6, 7,
8, 9}. Representamos um nmero nesta base (por exemplo, o 152) da seguinte forma:
152 15210 = (1 102 ) + (5 101 ) + (2 100 ) ,
O sub-ndice 10 usado para indicar a base numrica. E como representamos um nmero na
base numrica do computador ou base 2[N4] ? Bem, fazemos da mesma forma que na base 10.
Vejamos o exemplo do nmero 101:
PRONNCIA DOS BINRIOS
A pronncia dos nmeros na base 2 no igual ao da base 10, isto , o nmero 101
pronunciado UM ZERO UM, enquanto que na base 10 pronunciado CENTO E UM
101 1012 = (1 22 ) + (0 21 ) + (1 20 ) = 510 ,

o qual representa no sistema decimal ao nmero 5. Observe que os trs dgitos binrios
podem representar oito valores possveis: do 010 (= 0002 ), 110 (= 0012 ), . . . , at 710 (= 1112 ).
Em geral, como mencionado anteriormente, se n bits so agrupados juntos para formar um
nmero binrio, ento eles podem representar 2n valores possveis. Assim, um grupo de 8
bits (1 Byte) pode representar 256 valores possveis. Numa implementao tpica, metade
[N4] Como curiosidade, se existissem extraterrestres com oito dedos, como voc esperaria que fosse a base representativa dos nmeros? Claro, pensando como Ser Humano!!!
destes valores so reservados para representar nmeros negativos e a outra metade para os
positivos. No caso 1 Byte (8 bits) utilizado usualmente para representar nmeros entre
128 e +127, inclusive.
Um sistema para representar os caracteres (de linguagens No-Orientais) deve incluir
os seguintes smbolos:
PERMITIDOS NO FORTRAN:
As 26 letras maisculas:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
As 26 letras minsculas:
abcdefghijklmnopqrstuvwxyz
Os dez dgitos:
0123456789
Smbolos comuns ou caracteres especiais:

<espao> ( ) , ? ! . : _ ; $
entre eles operadores aritmticos:
e lgicos: <
&
+ /
> == >= <= / =
NO PERMITIDOS NO FORTRAN:
Algumas letras especiais ou smbolos, tais como:

@ # [ ] { } entre outros.
O nmero total de caracteres e smbolos requeridos menor do que 256, mas mesmo
assim utilizado 1 Byte de memria para armazenar cada caracter. Embora incompleto,
este o sistema de cdigo ASCII (American Standard Code for Information Interchange), usado
na maioria dos computadores. Atualmente, est no processo de implementao um outro
sistema de cdigo mais geral, chamado Unicode, que contemplar tambm as linguagens
orientais. Na verso Fortran 2003, este sistema de cdigos j est disponvel.
Todas as mquinas tem um tamanho de palavra"(wordsize) uma unidade fundamental de armazenamento, por exemplo, 8 bits, 16 bits, etc. Esta unidade difere entre as
mquinas, em um processador Pentium , por exemplo, poder ser de 32 bits (4 Bytes). Isto
ser importante mais adiante, na pg. 22.
Outro conceito interessante o Flop, que uma operao de ponto flutuante por segundo. Uma operao de ponto flutuante ocorre quando dois nmeros reais so adicionados.
Hoje, se fala de MegaFlops ou at mesmo em GigaFlops.
Para finalizar, um comentrio a respeito de processamento paralelo (ou vetorizao).
O processamento paralelo ocorre quando duas ou mais CPUs[N5] trabalham simultaneamente na soluo de um mesmo problema. Assim, obtm-se maior velocidade e volume
de processamento computacional. Para fazermos uso deste procedimento necessrio que
o compilador Fortran 95 nos habilite tal procedimento e que o programa seja projetado com
este objetivo, i.e., implementando as declaraes intrnsecas para o processamento paralelo.
[N5] CPU:
Central Processor Unit ou, no bom portugus, Unidade Central de Processamento.
Como exemplo de compiladores comerciais que habilitam a vetorizao temos, entre outros,
o Lahey-Fujitsu Fortran 95 for GNU/Linux da Lahey Computer Systems, Inc. [7] e o PGHPF da
Portland Group [8], este por sinal um excelente compilador. O compilador G95 tambm
permite o processamento paralelo.
1.3
COMO TRABALHA A MEMRIA DO COMPUTADOR?
Para entendermos como funciona a memria do computador, usaremos um exemplo
hipottico, cujo tamanho de palavra de 8-bits:
3F29
3F2B
3F2A
3F2C
A memria dos computadores enderevel, i.e., para cada alocao de memria dado
um nmero especfico, o qual freqentemente representado em hexadecimal (base 16), por
exemplo, 3F2C. Mas, porque usar base 16? Vejamos sucintamente o motivo no quadro abaixo.
SISTEMA HEXADECIMAL
Os computadores trabalham no sistema dos nmeros binrios, mas ns simples mortais
pensamos no mundo do sistema de nmeros decimais. Felizmente, podemos programar os
computadores para aceitarem os nossos nmeros decimais, convertendo-os internamente
para os binrios da mquina. Mas, quando os cientistas, tcnicos e engenheiros trabalham
diretamente com o sistema binrio percebem que o mesmo difcil de manipul-los. Vejamos, por exemplo, o nmero 110010 no sistema decimal, que escrito 0100010011002
no sistema binrio. Para evitar difcil manipulao no sistema binrio, uma alternativa
quebrar o nmero binrio em grupos de 3 e 4 bits e com isso obter novas bases, respectivamente, base 8 (series octal) e base 16 (series hexadecimal). Vejamos ltima representao,
a base 16 ou hexadecimal. Um grupo de 4 bits pode representar qualquer nmero entre
0(= 00002 ) e 15(= 11112 ) (lembram do 2n ?). Ento, um nmero hexadecimal tem 16 dgitos: 0, 1, . . . , 8, 9 mais de A, B, . . . , E, F. Assim, 916 = 910 ; A16 = 1010 ; B16 = 1110 ; e assim
por diante. Podemos quebrar um nmero binrio em grupos de 4 e substituir os dgitos hexadecimais apropriados para cada grupo. Vejamos o nosso nmero 110010 = 0100010011002 .
Quebrando-o em grupos de 4, temos: 0100|0100|11002 . Substituindo cada grupo pelo apropriado hexadecimal, obtemos 44C16 , que representa o mesmo padro de bits do nmero
binrio, mas de maneira simplificada
A CPU est habilitada a ler e escrever numa especfica localizao (rea) de memria.
Grupos de reas de memria so tratados como informaes inteiras (no nmeros inteiros) possibilitando assim armazenar mais informaes. Usar a identificao criptogrfica hexadecimal para localizao de memria incomum (porque mais complicado!!), assim o
Fortran 95 possibilita substitu-las por nomes (em ingls).
10
Quando os computadores so ligados, cada localizao de memria conter algum tipo

de valor, e neste caso os valores sero aleatrios (randmicos). Em geral, os valores sero
os que permanecem na memria do uso anterior. Por esta razo, muito importante inicializar as localizaes de memria antes de comear qualquer manipulao da mesma como
clculos, declarao de variveis, etc.
Todas as CPU tem um conjunto de instrues (ou linguagem prpria da mquina) para
sua manipulao. De maneira geral, todos os programas Fortran 95 so convertidos (ou compilados) para o conjunto de instrues (ou linguagem de mquina). Grosseiramente falando,
todos os processadores tm o mesmos tipos de instrues. Assim, a CPU pode dizer coisas
como, busque o contedo da rea de memria 3F2C ou escreva este valor na localizao
(rea) de memria 3F2A. Esta basicamente a maneira de como os programas trabalham.
Considere a seguinte seqencia de instrues em cdigo assembler:
LDA 3F2C carregue (ou busque) os contedos de 3F2C
ADD 3F29 adicione estes contedos em 3F29
STO 3F2A armazene o valor resultante na localizao 3F2A
Esta seqencia de instrues, que tem significado somente ilustrativo para os nossos
propsitos, efetivamente adiciona dois nmeros e armazena o resultado numa rea de memria diferente. At 1954, quando o primeiro dialeto da linguagem Fortran foi desenvolvido, todos os programas de computador eram escritos usando o cdigo assembler. Foi John Backus
e sua equipe, ento trabalhando na IBM, que props e desenvolveu um mtodo econmico
e eficiente de programar. A idia foi de projetar uma linguagem que possibilitasse expressar
frmulas matemticas de uma maneira mais natural do que na poca era feito somente com a
linguagem assembler. Do resultado de suas primeiras tentativas surgiu o FORTRAN (forma
abreviada para IBM Mathematical FORmula TRANslation System).
Esta nova linguagem possibilitou que as instrues acima fossem escritas de maneira
menos criptografada, como por exemplo:
K =I +J.
A seguir veremos a diferena entre compiladores, interpretadores e depuradores.
Compilador
Compilador um programa que, a partir de um cdigo-fonte escrito em uma linguagem de
programao (de alto nvel), cria um programa semanticamente equivalente porm escrito
em outra linguagem, conhecido por cdigo-objeto ou linguagem de mquina (ou ainda, instrues de cdigo assembler), o qual chamaremos simplesmente de executvel.
As principais numa compilao, a partir de um cdigo-fonte, so:
1. Anlise lxica: processo que analisa a entrada de linhas de caracteres de um cdigofonte, caractere a caractere, e produz uma seqncia de smbolos chamado smbolos lxicos, ou simplesmente smbolos (tokens), que podem ser manipulados mais facilmente,
na segunda etapa, por um parser, conhecido como leitor de sada.
11
2. Anlise sinttica (parsing): processo que analisa uma sequncia de entrada para determinar sua estrutura gramatical segundo uma determinada gramtica formal. Nesta
etapa identificada, por exemplo, que o WRTE est incorreto. O correto WRITE, que
uma instruo de escrita.
3. Anlise semntica: a fase da compilao em que verifica se as estruturas do programa
faro sentido durante a sua execuo, ou seja detecta os erros semnticos. Por exemplo, verifica a multiplicao entre tipos de dados diferentes, tal como nmero inteiro
multiplicado por um nmero real. Nesta etapa preparada, por meio de coleta as informaes, a prxima fase da compilao que a fase de sntese, por pelo menos mais
trs etapas.
4. Gerador de cdigo intermedirio: como o prprio nome traduz, um passo intermedirio, que em alguns casos poder ser o cdigo-objeto final.
5. Otimizador de cdigo: nesta etapa o cdigo intermedirio otimizado em termos de
velocidade de execuo e espao de memria.
6. Gerador do Cdigo-objeto: nesta fase gerado o cdigo-objeto, otimizado ou no,
dependendo das opes de compilao. Os objetivos desta etapa so, por exemplo,
reserva de memria para as variveis e de dispositivos de entrada e sada de dados.
Ento, gerado o executvel, em linguagem de mquina, para uma determinada arquitetura de computador, isto , dependente de mquina.
Para auxiliar na compreenso de algumas funes de um compilador, usaremos uma
analogia com a linguagem portuguesa. Seja a seguinte afirmao:
Ela comprar duas febre, e tambm comprar um cordeiro, ambos amaa.
Inicialmente, numa anlise lxica, verifica-se que o caracter no pertence ao conjunto de
smbolos da lngua portuguesa. Para corrigir, os dois caracteres a sero substitudos por
nh. Na anlise sinttica verificado se a estrutura est em acordo com as regras gramaticais.
Neste caso, ser detectado dois erros, que sero corrigidos por:
comprar
comprar,
febre
febres.
Na anlise semntica verificado se a frase faz sentido. E, neste exemplo no apresenta

significado, porque febre no objeto venal. Provavelmente houve um engano, e a afirmao
correta seja
Ela comprar duas lebres, e tambm comprar um cordeiro, ambos amanh.
E por fim, uma otimizao pode ser realizada, se o autor desejar, porque a frase est correta
e compreensvel. Se for o caso teremos, por exemplo:
Ela comprar duas lebres e um cordeiro amanh.
12
No Fortran: o compilador evocado, assim como para outros tipos de compiladores, por
uma palavra chave, que depende de compilador para compilador. No nosso caso o g95,
do Fortran G95. Ao compilar anexado ao cdigo, entre outras, instrues matemticas,
instrues de dispositivos de entrada e sada de dados, por exemplo, via teclado e via monitor, respectivamente. Os arquivos executveis gerados so especficos para cada processador
e/ou sistema operacional, isto , cdigo compilado num computador com processador Intel
Pentium ou AMD no ser executado numa Estao Sun SPARC e vice-versa. Da mesma
forma, um cdigo compilado num computador com sistema operacional Windows no ser
executado num computador com sistema operacional Linux, UNIX ou MacOS e vice-versa.
Assim, quando trocarmos de plataforma (processador e/ou sistema operacional), devemos
compilar novamente o cdigo. Observe que um termo novo, cdigo ou cdigo computacional, foi introduzido e se refere a um programa de computador gerado com uma linguagem
de programao.
No Apndice ??, na pg. ??, apresentado o compilador G95, utilizado como referncia
neste livro. indicado como baix-lo na internet e instal-lo, tanto para a plataforma Windows como para Linux. Exemplos de uso do compilador esto descritos a partir da pgina 16.
Existe outra forma de executar um programa de computador gerado por uma linguagem de programao. So os interpretadores. E para corrigir erros em programas podemos
recorrer aos depuradores, os quais veremos resumidamente a seguir.
Interpretador
Os interpretadores so programas que lem um cdigo-fonte de uma linguagem de programao e o executam. Seu funcionamento pode variar de acordo com a implementao e,
em muitos casos o interpretador l linha-a-linha e converte em cdigo-objeto medida que
vai executando o programa. Linguagens interpretadas so mais dinmicas e apresentam a
seguinte sequncia:
escrever cdigo = testar = corrigir = escrever = testar = distribuir.
J os compiladores tem uma sequncia dada por:
escrever cdigo = compilar = testar = corrigir = compilar = testar = distribuir.
Mas existem tambm linguagens que funcionam como interpretadores e compiladores, como
por exemplo: Python (somente quando requerido), BASIC, entre outras. Outros exemplos de
linguagens interpretadas so: Bash, C#, Perl, PHP, Python, Euphoria, Forth, JavaScript, Logo,
entre outras.
Depurador
Depurador, tambm conhecido por debugger, um programa usado para testar outros programas e fazer sua depurao, ou seja, indica seus problemas ou bugs[N6] .
Em geral, os depuradores oferecem as seguintes funcionalidades:
[N6] Bug significa em ingls qualquer tipo de inseto. Os primeiros computadores de tamanhos de grandes salas
paravam os processamentos devido a insetos que se localizavam em seus dispositivos. Para retornar ao trabalho era
preciso retirar os insetos, ou seja, fazer um debugging. Assim, este termo foi mantido no meio acadmico e at hoje
utilizado para erro e procura de erros.
13
1. a execuo passo-a-passo de um programa, chamada single-stepping;

2. a suspenso do programa para examinar seu estado atual, em pontos predefinidos,
conhecidos como breakpoints, ou pontos de parada; e
3. o acompanhamento do valor de variveis que tambm o programador pode definir, por
meio das watch expressions, que podem ser usadas inclusive para gerar uma suspenso,
ou ativar um breakpoint: por exemplo, em um programa que calcula a raiz quadrada,
uma dessas condies seria se a varivel que contm o argumento passasse a ser negativa.
Na seo 1.8, pg. 38, trataremos a respeito de erros em Fortran 95. Veremos a seguir
como criar e executar o primeiro programa em Fortran. Mas, antes precisamos dos conceitos
de unidades de programas. Para obter mais informaes a respeito do processo de compilao, aconselha-se o livro descrito na ref. [12].
1.4
AS UNIDADES DE PROGRAMA
Unidades de programa so os menores elementos de um programa Fortran que podem
ser compilados separadamente. Existem cinco tipos de unidades de programas:
Programa Principal (ou Main Program)
Sub-Programa FUNCTION (so as funes definidas pelo usurio)
Sub-Programa SUBROUTINE (so as sub-rotinas)
Unidade de Programa BLOCK DATA
Unidade de Programa MODULE
A seguir veremos o primeiro tipo. Os subprogramas SUBROUTINE e FUNCTION esto

descritos no Captulo 6, na pgina 97. A unidade de programa MODULE apresentada no
Captulo 8, na pgina 111. A unidade de programa BLOCK DATA no ser abordada neste
livro. Um BLOCK DATA fornece valores iniciais para dados compartilhados por uma ou mais
unidades de programas. Uma leitura complementar sobre estas unidades de programa so
encontradas nas referncias indicadas ou no Manual do Usurio do compilador.
Programa Principal (Main Program)

A execuo de um programa principal inicia com a primeira declarao ou instruo executvel no programa principal e finaliza com a instruo END do programa principal ou com
uma instruo STOP, localizada em qualquer lugar do programa. De fato o que determina
a finalizao do programa o END. Quando encontrado um STOP ele remete o fluxo de
execuo incondicionalmente para o END, e assim a execuo do programa abortada.
A forma estrutural de um programa principal em Fortran 95 :
fortran
95
14
[PROGRAM nome_do_programa]
[USE nome_do_use]
[IMPLICIT NONE]
[declarao global dos dados]
instrues executveis e no-executveis
[CONTAINS]
[subprogramas internos]
END [PROGRAM nome_do_programa]
em que, os colchetes indicam que o elemento Fortran opcional[N7] e, a ordem obrigatria
est indicada na seqencia exposta. uma boa prtica de programao iniciar o cdigo
com a instruo PROGRAM seguida do referido nome, tornando claro o incio do programa
principal. Cada um dos itens da estrutura sero tratados no decorrer do livro.
Um cdigo computacional tem um e somente um programa principal. a estrutura de
referncia, isto , o compilador reconhece somente um END que obrigatrio, ou quando
existir, inicialmente, somente um PROGRAM que opcional. Para as demais unidades de
programa no h nmero mnimo ou mximo de aparies.
Antes de criarmos os dois primeiros programas, importante e necessrio vermos alguns elementos do Fortran 95.
O FORMATO LIVRE
No Fortran 95 podemos escrever em qualquer coluna (posio) na linha e temos 132 posies
para ocupar. Este chamado de formato livre. No FORTRAN 77, verso anterior ao Fortran
90/95, se inicia o cdigo a partir da coluna 7 at 72. As colunas 1 at 6 so utilizadas para
instrues de controle de fluxo do cdigo e para localizao de rtulos, como os utilizados na
instruo FORMAT. A coluna 6, especificamemte, indica, pela escrita de um caracter qualquer,
a continuao da linha anterior. Da coluna 73 at 80 o campo de identificao do carto.
Esta estrutura, chamada de formato fixo, era devido ao carto de digitao, em que cada
linha tinha 80 colunas (posies) para ser perfurado, para posterior manipulao de leitura e
processamento pelo computador. O Fortran 95 tambm suporta o formato fixo.
O CONJUNTO DE CARACTERES
O conjunto de caracteres do Fortran consiste, como visto na pgina 8, de:
As 26 letras maisculas:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
As 26 letras minsculas:
abcdefghijklmnopqrstuvwxyz
Os dez dgitos:
0123456789
[N7] Lembrando a conveno: neste livro, os colchetes sempre indicaro que o elemento (por exemplo, uma declarao, uma instruo ou um atributo) opcional.
15
Smbolos comuns ou caracteres especiais:

<espao>[N8] = + / < >
&
Em Fortram as letras maisculas so equivalentes as correspondentes minsculas, exceto

quando estiverem relacionadas com as declaraes do tipo CHARACTER, que ser estudado
na seo 1.5.4, na pgina 24. Isto , para o Fortran os nomes TESTE, teste, Teste e TeStE
so equivalentes no h distino entre maisculas e minsculas, ou seja, no tipo CASE
SENSITIVE.
O caracter ponto-e-vrgula (;) pode ser usado para separar duas ou mais instrues
numa mesma linha, como por exemplo:
READ(*,*) x; WRITE(*,*) Ola amigo ...
cujo significado , respectivamente, leitura via teclado de um valor para armazenar na varivel x e escrita da frase Ola amigo..., que est entre as aspas. Ambas instrues sero
estudadas no Captulo 2 e varivel um elemento que armazenar algum valor e ser estudada na pgina 25. Outros exemplos:
a = 23 ; b = 150 ; c = 23.76
que significa, atribuio de valores s variveis a, b e c. A atribuio de valores s variveis
ser estudada na pgina 27.
OS NOMES SIMBLICOS EM FORTRAN
Os nomes simblicos so utilizados em Fortran para se referir a vrios elementos como nomes
de programa e de variveis. Um nome inicia, necessariamente, com uma letra e ter no
mximo at 31 caracteres, os quais podero ser letras, dgitos e underscore trao-baixo
( _ ). proibdo o uso de caracteres especiais, de caracteres acentuados ou cedilhados, tais
como: <espao> = + / < > ( ) , ? ! . : ; $ % & * @ # [ ] { } . So chamados de
simblicos, como mencionado anteriormente (pg. 10), porque substituem aquelas instrues
de mquina de localizao de elementos na memria.
Exemplos de nomes vlidos em Fortran:
t_2006
t2006
primeiro_programa
Metodo_LTSN
AaBb
Calculo_integral_definida
soma
SOMA
Soma
Exemplos de nomes invlidos em Fortran:

2_t_2006
primeiro programa
calculo_do_
ilegal_@_caracter
ao_distncia
nome_muito_longo_nao_pode_ser_usado
D nomes as variveis e as unidades de programa que representem, mais prximo possvel,

o que elas processaro. Por exemplo, se uma varivel armazenar o valor de pi, ento
conveniente cham-la de pi. Outro, se uma expresso calcular o salrio de um funcionrio,
aps o seu aumento, interessante cham-la de salario_final.
[N8] <espao>
significa um espao em branco.
16
OS RTULOS EM FORTRAN
Os procedimentos ou instrues em Fortran podem ter suas posies identificadas no programa. Essa identificao conhecida como rtulo e descrito por um (1) at cinco (5) algarismos, sendo o primeiro algarismo no nulo. localizado sempre a esquerda na linha, antes
da instruo ou procedimento. Os rtulos so importantes, por exemplo, na instruo no
executvel FORMAT, que ser estudada na seo 2.6 do Captulo 2, na pgina 56.
Exemplos de rtulos vlidos em Fortran:
200
1234
20000
10
00010
Os dois ltimos rtulos so equivalentes. Um mesmo rtulo no poder identificar duas ou

mais linhas na mesma unidade de programa. O rtulo (e por consequncia instrues ou
procedimentos) poder ser invocado (chamado) quantas vezes for necessrio.
O PRIMEIRO PROGRAMA
Veremos um exemplo simples de programa escrito na linguagem Fortran 95: O primeiro programa. Como de praxe em qualquer livro de linguagem de programao, o primeiro programa apresentado sempre ensina como escrever uma mensagem na tela do monitor. Isto
tem um significado importante: todos os procedimentos realizados por um programa (ou cdigo
computacional), como por exemplo clculos de expresses matemticas, precisam ser apresentados
para o usurio e isso s possvel por intermdio de uma sada de informao. Caso contrrio, todas as informaes manipuladas ficaro aprisionadas na memria do computador sem que saibamos
seus valores, e se perdero ao desligar o computador.
Como mencionando anteriormente, no Apndice ?? apresentado com detalhes, como
obter, instalar e utilizar o compilador Fortran G95, tanto para o sistema operacional Windows
como para o Linux. No Apndice ?? apresentada uma lista de outros compiladores Fortran.
Para criar um programa necessrio seguir os trs seguintes passos[N9] :
1. Digite o cdigo fonte em um editor de texto e salve-o com a extenso .f90.

O termo cdigo fonte ser utilizado para o arquivo contendo as instrues Fortran 95
em modo texto.
[N9] Existem compiladores Fortran que apresentam uma rea de trabalho totalmente integrada, isto , possvel num
mesmo ambiente digitar o cdigo fonte, compil-lo para gerar o executvel e execut-lo. o caso, por exemplo, dos
compiladores Lahey, PowerStation e Portland.
17
O EDITOR DE TEXTO
Para elaborao do programa Fortran possvel utilizar qualquer editor, com exceo daqueles que ao salvar o arquivo anexem instrues de controle do prprio editor. Assim, ao
compilar o programa contido neste arquivo poder ocorrer um erro de compilao devido a
estas instrues (muitas vezes caracteres) de controle. Assim, evite o WORD e o WORDPAD, no caso do Windows. Utilize o NOTEPAD (o mesmo que BLOCO DE NOTAS) para
digitar os programas, e salve-o com a extenso .f90 ou .f95. Importante: habilite no
Salvar como a opo Todos. Assim ser evitado o indesejvel acrscimo da extenso
.txt aps a extenso .f90 ou .f95. No Linux, em princpio, pode-se utilizar qualquer
um dos editores de texto disponveis.
2. Gere o programa executvel usando o comando g95 do compilador G95.

Importante:
Antes de seguirmos, uma advertncia: ser dado preferncia por instrues utilizadas
no GNU/Linux[13]. Para usurios do Windows, a transferncia de instrues quase
automtica para uso no terminal DOS. Por exemplo, para acionar o compilador G95, j
instalado, utilizado o comando g95 tanto para o sistema operacional GNU/Linux[N10]
como para o Windows, isto , no terminal do DOS ou do GNU/Linux[N11] digitamos
esta palavra chave seguida do nome do programa em Fortran 95.
Assim, para gerar um executvel, digite no terminal DOS ou num terminal Linux:
g95 nome_programa.f90
Este comando:
1 ) verifica, no programa (cdigo fonte), as sintaxes das instrues Fortran,
2 ) na sequncia, gera um cdigo objeto com nome nome_programa.o,
3 ) e repassa o cdigo objeto para o linkador[N12] , que anexa bibliotecas (sistema,
E/S (Entrada/Sada de dados), etc.) e gera um executvel, com um nome default
chamado a.out no Linux e a.exe no Windows.
Para alterar o nome do arquivo executvel possvel utilizar uma opo do compilador,
a -o seguida do nome que se deseja para o executvel. Assim, temos para o exemplo
acima:
g95 -o nome_de_saida nome_programa.f90
[N10] Para
exemplificar o uso de outro compilador, por exemplo, o da Lahey/Fujitsu for GNU/Linux, compila-se com o
comando lf95.
[N11] Conselho: se voc no trabalha com o sistema operacional GNU/Linux, experimente !!! gratuito e no por
isso ineficiente, pelo contrrio, altamente estvel e confivel.
[N12] Infelizmente, na falta de uma palavra apropriada em Portugus, para a ao de quem faz um link (ligao, vnculo,
elo), que reforce a idia em computao, estou usando linkador.
18
O nome de sada, no caso do Linux, pode ser acrescido de uma extenso ou no. Para o
Windows interessante acrescentar a extenso EXE (mas no necessrio), para evitar
algum problema referente a estrutura de arquivo.
Para outras opes do compilador, consulte o manual do Usurio. Somente para o
Linux, digite man g95 para ler o manual.
No 3 item acima, o compilador anexa ao cdigo, entre outras coisas, clculos matemticos, entrada de dados, e sada de resultados. Por exemplo, as entradas podem
ser via teclado, arquivo (pg. 50) ou outro dispositivo. As sadas podem ser via monitor, impressora, arquivo ou por outro dispositivo. importante relembrar que os
arquivos executveis so especficos para cada processador e/ou sistema operacional.
Ou seja, um cdigo compilado num computador, com G95 por exemplo, num processador Intel Pentium no ser executado numa Estao Sun SPARC, e vice-versa. Da
mesma forma, um cdigo compilado num computador com sistema operacional Windows no ser executado num computador com sistema operacional Linux e vice-versa.
Assim, quando trocarmos de plataforma (processador e/ou sistema operacional), devemos compilar novamente o cdigo.
3. Execute o cdigo (programa) usando o comando:
No Linux:
./nome_programa ou ./a.out
No Windows:
nome_programa.exe ou a.exe
ou simplesmente:
nome_programa ou a
Agora que sabemos a sequncia da criao de um programa Fortran, segue abaixo um

programa que imprime uma mensagem na tela do monitor.
Programa 1.1 O primeiro programa.
WRITE(*,*) Ola mundo externo ....
END
Digite-o num editor de texto preferido, salve-o com um nome desejado, compile-o, conforme descrito na pgina 17 e aps execute-o. Este o mais simples dos programas em
Fortran. Contm apenas duas linhas e utiliza a instruo WRITE(*,*) para transferir para a
tela do monitor a frase Ola mundo externo ...., que est contida entre as aspas simples.
As aspas simples podem ser substitudas por duplas aspas, por exemplo, para contemplar a
seguinte sada, que contm uma aspa simples no seu texto:
WRITE(*,*) "A queda dagua eh bonita."
END
Observe, novamente, que todo programa Fortran 95 termina com a instruo END.
O SEGUNDO PROGRAMA
Neste exemplo, o programa 1.2, j so apresentadas boas prticas de programao que sero
descritas na sequncia. O cdigo transforma o valor do ngulo em graus para radianos, e
19
imprime o valor do cosseno do ngulo. Todo o procedimento foi executado em preciso

simples, cujo tema ser tratado na pgina 23. A numerao a esquerda no faz parte do
cdigo e a sua utilizao para melhor explicar cada linha do cdigo (ou programa). Esta ser
uma prtica daqui para frente. Lembre-se que ainda ters contato com todos os elementos
Fortran, portanto, se no compreender alguma descrio ela ser tratada ao longo do livro.
Programa 1.2 Exemplo de programa que converte ngulos em graus para radianos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
PROGRAM graus_para_rad
IMPLICIT NONE
!
! Este programa converte angulos em graus para radianos
!
REAL :: theta, ang_rad
REAL, PARAMETER :: pi=3.14159265
WRITE(*,*)"Indique um angulo em graus: "
READ(*,*)theta
ang_rad = theta*pi/180.0 ! Aqui ocorre a conversao
WRITE(*,*) O angulo ,theta,, em graus, vale,&
ang_rad, radianos
WRITE(*,*) cos(theta) = ,COS(ang_rad)
END PROGRAM graus_para_rad
Procurou-se neste exemplo deixar clara a estrutura de um programa Fortran 95 e observe que as instrues da linguagem esto em negrito. Embora seja opcional, um programa
Fortran 95 inicia com a instruo PROGRAM seguida do nome do programa. Na sequncia
constam as declaraes de variveis, entre as linhas 2 e 7. O corpo do programa, que contm
as instrues excutveis (e tambm no executveis), est entre as linhas 8 e 13. E, finaliza
com a instruo END seguida do nome do programa.
A seguir veremos uma descrio de cada linha, indicando o que executa ou instrui o
computador a realizar. Aproveitaremos para indicar as boas prticas de programao e algumas exigncias da linguagem Fortran.
Linha 1: Nesta linha ocorre o incio do cdigo ou programa em Fortran. A palavra-chave
PROGRAM seguido do nome do programa. Como visto anteriormente, na pgina 15,
devemos ter cuidado ao nomear um programa. O nome de um programa Fortran 95
ter at 31 caracteres e iniciar sempre com uma letra do alfabeto, poder conter letras,
algarismos e o caracter trao baixo ou underscore ( _ ).
Reiterando, embora seja opcional, uma boa prtica de programao colocar a instruo
PROGRAM (sempre na primeira linha) seguida de um nome.
Linha 2: O IMPLICIT NONE, que j estava disponvel nas ltimas verses do FORTRAN 77,
obriga-nos a declarar todas a variveis do problema, auxiliando a depurar eventuais
erros de escrita ou de dupla declarao. Embora seja opcional, tambm uma boa prtica
de programao colocar a instruo IMPLICIT NONE.
Linha 3: O caracter ! (sinal de exclamao) instrui o compilador que a sua direita o con-
fortran
95
fortran
95
20
tedo seja ignorado, ou seja, a linha apenas um comentrio no programa. uma boa
prtica de programao escrever comentrios a respeito de certas atitudes e linhas do
programa. Assim, comente o mximo possvel o seu programa. Neste caso foi utilizado
simplesmente para deixar uma linha em branco, embora no Fortran possvel deixar em
branco quantas linhas desejar, sem a necessidade do sinal de exclamao.
Linha 4: Nesta linha o comentrio para descrever a utilizao do programa. O uso de
comentrios evita o esquecimento, por exemplo, do significado de cada varivel ou do
que trata o programa, fato que comum com o passar do tempo. Ou ainda, possibilita
que outros programadores entendam melhor o que foi programado. Escreva o objetivo
do programa e das sub-rotinas. Insira tambm formas de contato com o programador,
como por exemplo, o e-mail. No esquea, aps o sinal ! o contedo ser ignorado.
Linha 5: Mais uma linha em branco comentada.
Linha 6: Aparece a primeira declarao global de varivel, que do tipo real. Observe
atentamente a sintaxe. Primeiro se escreve o tipo de dado (varivel) seguido de dois
dois-pontos e, na sequncia, separados por vrgulas as variveis. Os nomes da variveis
seguem os mesmos critrios que vimos para o nome do programa. aconselhvel nomear as variveis com nomes mais prximo possvel da sua funo no programa. Por
exemplo, theta, no jargo matemtico est relacionado com ngulo, assim como o nome
ang_rad, ngulo em radianos. As declaraes de variveis sero estudadas com mais
detalhes na pgina 25.
Linha 7: Aparece a segunda declarao de varivel, que tambm do tipo real. Note que
foi acrescentado um parmetro na declarao: o PARAMETER, que instrui o compilador
a fixar o valor da varivel pi ao longo de todo o programa, no permitindo que seja
alterado. Uma tentativa de alterar o valor de pi acarretar num erro de execuo. A
diferena para a declarao anterior que as duas variveis, theta e ang_rad, podem
ser alteradas a qualquer momento no programa, enquanto pi permancer constante durante toda a execuo.
Linha 8: Nesta linha aparece a primeira instruo executvel: o WRITE, que uma instruo de sada de resultado (ou de escrita ou impresso). Neste caso, devido ao primeiro
asterisco (*), a sada ser na tela do monitor. Note que a mensagem est entre duplas
aspas.
Linha 9: Agora uma instruo executvel de leitura apresentada: o READ, que receber um
valor para a varivel theta digitada via teclado, tambm, devido ao primeiro asterisco.
Mais informaes a respeito de instrues de leitura e escrita esto no Captulo 2, na
pg. 49.
fortran
95
Linha 10: Nesta linha ocorre a converso de graus para radianos, por intermdio de uma
expresso matemtica. Observe que o sinal de igual no indica uma igualdade propriamente dita, mas sim uma atribuio (que ser estudado na pgina 27). Isto , primeiro
so realizadas todas as operaes no lado direito da igualdade para posterior atribuio
do resultado final varivel, neste caso a varivel ang_rad. Note tambm que foi adicionado um comentrio aps uma instruo. Esta mais uma caracterstica do Fortran 95,
isto , permite que se faa comentrio em qualquer parte do programa, sempre iniciando
com um !.
21
Linha 11: Nesta linha impresso, pelo WRITE, o resultado das operaes executveis anteriores, e novamente na tela do monitor. Agora uma mltipla sada, todas separadas
por vrgula, que envolve valores armazenados nas variveis (que ser estudado na pgina 27), e de frases literais (entre aspas). Observe tambm o caracter &, que posicionado
no final da linha indica que a linha continuar na seguinte. Se um nome, palavra-chave
ou constante quebrado por um &, o primeiro caracter da prxima linha deve ser outro
&, seguido do restante do nome, palavra-chave ou constante. Veja o exemplo:
11
12
WRITE(*,*) O angulo ,theta,, em graus, &

&vale, ang_rad, radianos
O nmero mximo permitido de continuaes de linhas igual a 39. Ateno: o & no
funciona no interior dos comentrios (!) e no pode ser seguido de um comentrio.
Linha 12: Aqui continua a linha anterior, indicado pelo & no final da linha 11. opcional o
uso de outro & no incio da linha, a no ser nos casos citados acima.
Linha 13: impresso o outro resultado, tambm na tela do monitor.
Linha 14: a linha que encerra o programa. Caso no tivssemos escrito a linha 1, poderamos encerrar o programa somente com a instruo END. Como escrevemos a instruo
PROGRAM graus_para_rad, devemos encerrar obrigatoriamente com a instruo END
seguido de PROGRAM graus_para_rad.
Encerramos a breve anlise do nosso segundo programa Fortran. Foi somente um exemplo, e assim deve ser encarado, porque existem outras tantas instrues, funes, declaraes
Fortran, que somente lendo este livro at o final ters uma boa noo antes de comear efetivamente a programar em Fortran. A medida que formos avanando outros programas sero
propostos.
Em resumo, a estrutura geral de um programa Fortran :
1.
BLOCO DA DECLARAO DAS VARIVEIS, que um conjunto de instrues noexecutveis que definem as variveis que sero utilizadas ao longo do programa. Os
sub-programas tem acesso as variveis declaradas nesta etapa via troca por parmetros.
2.
BLOCO DE EXECUTVEIS - o corpo do programa (contm entradas e sadas de dados

inclusive), ou seja, o cdigo em si. Embora o bloco seja chamado de executvel, poder
conter instrues no-executveis.
3.
BLOCO DE ENCERRAMENTO DO PROGRAMA, que so instrues que finalizam

o programa e podem ser: END [PROGRAM] e STOP, este poder aparecer em qualquer
parte do programa e quantas vezes for necessria. J o END [PROGRAM] nico.
A seguir, para avanarmos no aprendizado da linguagem Fortran, veremos como funciona a despensa de dados para o Fortran, especialmente como armazenar e manipular
nmeros inteiros e reais, na sequncia os complexos.
fortran
95
22
1.5
A DESPENSA DE DADOS NO FORTRAN 95
O Fortran disponibiliza uma variedade de maneiras para armazenar e lidar com os dados. Os tipos de dados suportados pelo Fortran so:
INTEIROS: nmeros nos quais no h fraes, ou que no possuem parte fracionria.

So exatos.
REAIS: nmeros que so representados com uma parte fracionria ou que possuem ponto
decimal. So conhecidos tambm como nmeros representados em ponto flutuante. Aqui
os nmeros reais so tratados com ponto decimal e no com a vrgula, como estamos
habituados no dia-a-dia.
COMPLEXOS: nmeros do plano complexo, que possuem uma parte imaginria (que
representada por um nmero real) e uma parte real (Na pgina 24).
LGICOS: so dados que assumiro somente um valor: verdadeiro ou falso (Na pg. 24).
CARACTERES: so dados constitudos por letras e smbolos (Na pgina 24).
Veremos com mais detalhes os inteiros e reais. Deixaremos para o estudante se aprofundar nos demais tipos de dados representativos no Fortran.
1.5.1
Dados Inteiros - INTEGER (Preciso Simples)
Os dados inteiros so armazenados exatamente na memria do computador e consistem de

nmeros inteiros positivos, inteiros negativos e zero. A quantidade de memria disponvel
para armazen-los depender de computador para computador, ou do wordsize do computador, e poder ser de 1, 2, 4 ou 8 Bytes. O mais comum de ocorrer nos computadores atuais
4 Bytes (32 bits).
Como um nmero finito de bits usado para armazenar cada valor, somente inteiros
que caiam dentro de um certo intervalo podem ser representados num computador. Normalmente, o menor nmero inteiro que pode ser armazenado em n-bits inteiros, chamada de
preciso simples, :
Menor Valor Inteiro = 2n1
e o maior valor que pode ser armazenado em n-bits inteiros :
Maior Valor Inteiro = 2n1 1
Para o caso tpico de 4 Bytes inteiros, temos para o menor valor e o maior valor possveis,
respectivamente, 2.147.483.648 e +2.147.483.647. Quando tentarmos usar valores abaixo
ou acima destes ocorre um erro chamado de overflow condition e indicado na execuo do
programa.
1.5.2
Dados Reais ou de Pontos Flutuantes - REAL
Os nmeros reais so armazenados na forma de notao cientfica. J sabemos que nmeros

muito grandes ou muito pequenos podem ser convenientemente escritos em notao cientfica. Por exemplo, a velocidade da luz no vcuo aproximadamente 299.800.000 m/s. Este
23
nmero ser mais manusevel se escrito em notao cientfica: 2,998 108 m/s. As duas
partes de um nmero expresso em notao cientfica so chamadas de mantissa e expoente
da potncia de dez. A mantissa 2, 998 e o expoente 8 (no sistema de base 10).
Na linguagem do computador os nmeros reais so escritos de forma similar, a diferena se encontra no sistema usado porque o computador trabalha na base 2. Assim, se
N -bits so dedicados para representar (e armazenar) um nmero real, parte reservada para
a mantissa e parte para o expoente. A mantissa caracteriza a preciso e o expoente caracteriza
o tamanho que pode ser assumido pelo nmero. nesta repartio, e tambm na quantidade,
de bits que comea a diferenciao entre os computadores e compiladores Fortran.
PRECISO SIMPLES (Single Precision)
A grande parte dos computadores usam como preciso simples 4 Bytes (32 bits o (wordsize) do computador) para repartir entre a mantissa e o expoente. Normalmente esta diviso
contempla 24 bits para a mantissa e 8 bits para o expoente. Assim, temos:
i) Mantissa (preciso) n = 24 bits (3 Bytes)
2n1 = 223 = 8.388.608 que equivale a 7 algarismos significativos,
ii) Expoente n0 = 8 bits (1 Byte)
0
2n = 28 bits = 225510 , sendo metade para a parte positiva e metade para a negativa
Assim, o intervalo dado por 2128 2127 , que resulta em 1038 1038 .
Isto quer dizer que um nmero escrito em preciso simples ter at 7 ou 8 algarismos significativos (dgitos decimais) e o seu expoente (da potncia de 10) deve estar contido no intervalo
entre 38 e 38. Excedendo a este intervalo acarretar no erro de overflow.
PRECISO DUPLA ou DUPLA PRECISO (Double Precision)
O Fortran 95 inclui uma possibilidade de representar nmeros reais de forma mais ampla,
do que a preciso simples - default nos computadores. Esta possibilidade conhecida como
Dupla Preciso (ou Double Precision). Usualmente a dupla preciso de 8 Bytes (ou 64 bits),
sendo 53 bits para a mantissa e 11 bits para o expoente. Assim, temos:
i) Mantissa (preciso) n = 53 bits
2n1 = 252 que equivale entre 15 e 16 algarismos significativos,
ii) Expoente n0 = 11 bits
0
2n = 211 bits = 2204810 , sendo metade para a parte positiva e outra para a negativa
Assim, o intervalo dado por 21024 21024 , que resulta em 10308 10308 .
Desta forma, um nmero escrito em preciso dupla ter at 15 ou 16 algarismos significativos
(dgitos decimais) e o seu expoente (da potncia de 10) deve estar contido no intervalo entre
308 e 308. Excedendo a este intervalo acarretar no erro de overflow.
24
1.5.3
Os Nmeros Complexos - COMPLEX
O estudo feito para os nmeros reais extensivo para os nmeros complexos. A forma geral
de um nmero complexo c = a + bi, em que c o nmero complexo, a (parte real) e
b (parte imaginria) so ambos reais, e i 1. Em Fortran, os nmeros complexos so

representados por dois nmeros reais constantes separados por vrgula e entre parnteses. O
primeiro valor corresponde a parte real e o segundo a parte imaginria. Vejamos os seguintes
casos em Fortran, cujo nmero complexo est ao lado:
fortran
95
(1.,0.)
1 + 0i (real puro)
(0.7071,0.7071)
0.7071 + 0.7071i
(1.01E6,0.5E2)
1010000 + 50i
(0,-1)
i (imaginrio puro)
Em que o E representa a base 10 e o nmero aps o expoente. Desta forma, o que vimos
para os reais, vlido para os complexos. A diferena est no procedimento Fortran, que
feito pela declarao COMPLEX, que veremos adiante. A funo CMPLX, que ser estudada na
pgina 32tabela 1.2, converte um nmero inteiro ou real em complexo.
Programando em Fortran 95 deveremos ter cuidado ao declarar as precises de nossas
variveis, j que tanto a definio de preciso simples como a de preciso dupla podem mudar de computador para computador[N13] . O Fortran 95 possibilita modificarmos a mantissa e
o expoente, para escrevermos programas que possam ser facilmente portveis entre processadores diferentes, com tamanho de palavra (wordsize) diferentes. Isto obtido por uma funo
intrnseca que seleciona automaticamente a mnima preciso especificada, mesmo quando se
troca de computador. Para os reais, esta funo a SELECTED_REAL_KIND, que veremos no
Captulo 7, na pgina 107. Para os inteiros temos a funo SELECTED_INT_KIND.
1.5.4
Os outros dados: LOGICAL e CHARACTER
Alm dos dados inteiros, reais e complexos, existem outros dois dados (ou tipos de variveis
para armazenar dados): os lgicos e os caracteres.
Os Lgicos (LOGICAL)
So dados que assumiro somente valor verdadeiro ou falso e, so especialmente teis em tomadas de deciso, que sero estudadas no Captulo 3, na pgina 63. Os valores so: .TRUE.
(Verdadeiro) e .FALSE. (Falso).
Os Caracteres literais (CHARACTER)
So dados constitudos por letras e smbolos e so formados pelo conjunto de cdigos da

American Standard Code for Information Interchange (ASCII), que determina um padro de caracteres, e est reproduzida parcialmente no Apndice A.
[N13] Exemplos
da dependncia da combinao Processador/Compilador:

num Supercomputador Cray
T90/CF90[14][15], a preciso simples 64 bits e a dupla 128 bits; j num PC/Lahey Fortran 95 e num PC/G95,
a preciso simples 32 bits e a dupla 64 bits.
25
1.6
A DECLARAO DAS VARIVEIS
Em Fortran, todas as variveis que armazenaro os dados devem ser declaradas. Uma
varivel sempre ter um nome, um tipo, um tamanho e um valor. So cinco os tipos de dados intrnsecos, trs numricos: INTEGER, REAL, COMPLEX, e dois no-numricos: LOGICAL
e CHARACTER. O tipo de declarao DOUBLE PRECISION, disponvel no FORTRAN 77,
ainda suportado pelo Fortran 95, mas considerado um subconjunto (ou um tipo kind) do
REAL.
Os tipos de dados foram tratados anteriormente e assumiremos que uma varivel armazenar algum tipo de dado. Ento estas duas palavras, dados e variveis, sero sinnimos,
no sentido que ambas esto relacionadas a valores que sero armazenados e manipulados
por intermdio de variveis.
A sintaxe geral de uma declarao de varivel :
<tipo> [([KIND=]<par_repres.>)][<atributos>][::] <variaveis>
em que:
<tipo> : um dos tipos de dados estudados anteriormente e podem ser: INTEGER, REAL,
COMPLEX, LOGICAL e CHARACTER, respectivamente representando, inteiros, reais, complexos, lgicos e caracteres.
([KIND=]<par_repres.>) : em Fortran 95, cada um dos cinco tipos intrnsecos anteriores possui um valor inteiro no negativo denominado parmetro de representao do tipo
de dado. Este parmetro o valor correspondente em bytes disponibilizados para sua
representao, como vimos em detalhes para os inteiros e reais, a partir da pgina 23.
Na normatizao da linguagem Fortran 90/95 ficou estabelecido um padro: qualquer
processador deve suportar pelo menos dois parmetros de representao (o KIND) para
os tipos de dados REAL e COMPLEX e pelo menos um parmetro para os tipos de dados
INTEGER, CHARACTER e LOGICAL.
A tabela B.1, no Apndice B, contm todos os tipos de dados, seus parmetros de representao e intervalos de armazenamento, baseado no compilador G95.
<atributos> :
outros:
so informaes adicionais a respeito do tipo de dado e podem ser, entre
DIMENSION(<forma>) : indica a forma de uma array, em que (<forma>) indica as di-
menses separadas por vrgulas. So exemplos:

unidimensional: DIMENSION(7), um vetor de 7 elementos;
bidimensional: DIMENSION(3,4), uma matriz 3 4, com 12 elementos.
Este argumento ser estudado no Captulo 4.
PARAMETER : indica que o dado ser constante ao longo de todo o programa, sem possi-
bilidades de alter-lo,
ALLOCATABLE : usado juntamente com o DIMENSION e indica que o tamanho da array
ser informado ao longo do programa e no no momento da declarao da varivel.

a chamada alocao dinmica de memria e ser estudada no Captulo 5.
26
Obs.:
Podem ser declarados mais de um atributo para a mesma varivel, os quais sero separados por vrgula.
Ao longo do livro sero apresentados outros atributos para a declarao de variveis.
:: :
os uso dos dois dois pontos opcional, mas ser obrigatrio caso deseja-se inicializar
a varivel no momento da sua declarao.
<variveis> : so os nomes das variveis que armazenaro os dados, separados por vrgulas. O nome de uma varivel poder ter at 31 caracteres e iniciar sempre com uma
letra do alfabeto, jamais com um algarismo, que poder ser utilizado a partir da segunda
posio, assim como o underscore (_). No conter caracter especial ( , ( ){ }[ ]! . : @ # $
% & *) em qualquer posio do nome, bem como letras acentuadas ou cedilhadas.
A ATRIBUIO DE VALOR VARIVEL
Uma varivel um registrador de posio de memria que pode conter qualquer dado, numrico e no-numrico, sendo possvel alterar ou no durante a execuo do programa.
No Fortran, uma varivel recebe um valor por intermdio do sinal de igualdade. Esta
operao recebe o nome de atribuio de um valor a uma varivel, conforme o exemplo:
a = 15
Aqui a varivel a recebeu o valor igual a 15, isto , foi atribudo a ela (na memria) o valor
inteiro 15. Esta interpretao importante porque poderemos ter o seguinte caso:
b = 6
b = 5 + b
! eh um acumulador
em que, inicialmente a varivel b recebe o valor 6, e numa instruo posterior receber um

valor que depender do seu valor anterior. Ou seja, o novo valor ser o anterior somado
de 5. Esta uma prtica muito utilizada em programao e a varivel b conhecida por
acumulador. Pelo ponto de vista matemtico teramos um erro, pois o resultado final seria
0 = 5, que um absurdo. Mas do ponto de vista computacional temos que o primeiro passo
resolver a expresso do lado direito da igualdade, que igual a 11, e aps atribuir o resultado
para a varivel do lado esquerdo da igualdade, que o reter na memria do computador.
A INICIALIZAO DE VARIVEIS
importante, conforme descrito na pgina 10, atribuir um valor inicial a todas as variveis
do programa. Desta forma se evita erros indesejveis de valores pre-atribudos devido a
sujeiras contidas na memria. A inicializao pode ser realizada j na declarao ou em
qualquer parte do programa, como no exemplo a seguir.
INTEGER :: a = 15, c
REAL :: h = 2.350
.
.
.
c = 260
27
VARIVEIS GLOBAIS e LOCAIS

Uma varivel, quanto ao seu uso no cdigo, poder ser global ou local. Uma varivel global uma varivel declarada em um procedimento MODULE e ativada pela instruo USE,
enquanto que uma varivel local aquela declarada no programa principal (PROGRAM) e no
interior de subprogramas, tais como funes (FUNCTION) e sub-rotinas (SUBROUTINE).
As variveis globais podem ser utilizadas (ou acessadas) em qualquer parte do cdigo,
inclusive no interior dos subprogramas. J as variveis declaradas locais, no programa principal e no interior dos subprogramas, no podem ser acessadas fora dos mesmos e no caso
dos subprogramas s existiro enquanto o referido subprograma estiver ativo no fluxo de
execuo do programa. O exemplo abaixo evidencia as diferenas entre elas.
Os procedimentos MODULE e as instrues USE sero estudadas no Captulo 8, na pgina 111 e, os subprogramas (FUNCTION e SUBROUTINE) no Captulo 6, na pgina 97. Mesmo
assim possvel compreender como so usadas aqui.
Programa 1.3 Exemplos de declaraes globais e locais.
1
2
3
4
MODULE var
IMPLICIT NONE
INTEGER :: a=1, b=2, c
END MODULE var
! VARIAVEIS GLOBAIS
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
PROGRAM teste_dec_global
USE var
!
IMPLICIT NONE
INTEGER :: res
!
CALL soma(res)
WRITE(*,*)"O resultado eh: ", res
CALL mult(res)
WRITE(*,*)"O resultado eh: ", res
CONTAINS
SUBROUTINE soma(z)
IMPLICIT NONE
INTEGER :: z, d=4
!
WRITE(*,*)"Informe o valor da
READ(*,*)c
z = a + b + c + d
END SUBROUTINE soma
END PROGRAM teste_dec_global
ativa as variaveis globais

VARIAVEl LOCAL
VARIAVEIS LOCAIS
variavel c (inteira): "
23
24
25
26
27
28
29
SUBROUTINE mult(z)
USE var
IMPLICIT NONE
INTEGER :: z, d=4
z = a * b * c * d
END SUBROUTINE mult
! ativa as variaveis globais

! VARIAVEIS LOCAIS
28
Ao executar o cdigo, informando que a varivel c receber o valor igual a 10, teremos
como sada:
O resultado eh: 17
O resultado eh: 80
importante compreender o que exatamente o cdigo executa, ento vejamos atentamente o que est ocorrendo.
a) O procedimento MODULE var contm a declarao das variveis, inteiras (INTEGER),
a, b e c, em que as duas primeiras foram inicializadas.
b) no programa principal (PROGRAM teste_dec_global) as variveis a, b e c so ativadas pela instruo USE var, e estaro disponveis para todos os procedimentos do
programa. A instruo USE sempre localizada logo abaixo o incio do programa ou
do subprograma, e o objetivo instruir o compilador a carregar os procedimentos do
mdulo.
c) na linha 10, o programa principal invoca (chama) um subprograma chamado de
SUBROUTINE soma, cujo nico parmetro de passagem nesta conexo a varivel
res, que receber o resultado de uma soma realizada no referido subprograma. Note
que na SUBROUTINE soma as variveis a, b e c no foram declaradas e nem foi necessrio a instruo USE var. A ausncia deste ltimo porque o subprograma est
contido no interior do programa principal, ao possibilitada pela instruo CONTAINS.
importante ressaltar que a instruo CONTAINS permite que subprogramas pertenam ao programa principal e, a sua localizao tal que os procedimentos abaixo sejam
somente SUBROUTINEs e FUNCTIONs.
d) na linha 24, outro subprograma (neste caso a SUBROUTINE mult) utilizado para realizar uma multiplicao de variveis. Observe que pelo fato de estar localizado externamente necessria a instruo USE var, para tornar as variveis a, b e c globais.
e) para encerrar, atente para a varivel c. Ela foi preenchida por uma entrada de dados
por meio de um READ, na linha 20, e automaticamente o valor atribudo disponibilizado globalmente, como pode ser verificado pela operao matemtica na linha 28.
Para melhor entendimento dos subprogramas recorra ao Captulo 6, na pgina 97, mas
abordaremos rapidamente os que utilizamos neste exemplo. Os subprogramas, so unidades
de programas e so os menores elementos de um programa Fortran que podem ser compilados separadamente. Os do tipo SUBROUTINE so ativados pelas instrues CALL, que trocam
parmetros entre o programa principal e os subprogramas. Os parmetros so dados trocados entre o programa principal e a SUBROUTINE, e esto localizados entre os parnteses, logo
aps as instrues CALL e SUBROUTINE. A ordem dos parmetros definida pelo usurio,
e deve ser mantida rigorosamente nas chamadas. As variveis no necessariamente tem o
mesmo nome no programa principal e nos subprogramas. Observe que no programa principal a varivel que receber a sada do subprograma res e no interior dos subprogramas z.
Para finalizar, toda vez que um subprograma ativado, o programa principal altera o
seu fluxo de execuo para o subprograma. Aps a realizao da tarefa do subprograma, o
29
fluxo retorna para a prxima linha aps a chamada (CALL). Observe tambm que a varivel
res retm o ltimo valor a ela atribudo e, que a varivel d do tipo local.
A seguir so apresentados exemplos de declaraes de variveis num programa Fortran:
Programa 1.4 Exemplo com declaraes de variveis num programa Fortran.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
INTEGER a, b, c
INTEGER :: ai_doi, junho_2001
INTEGER :: dia = 1
INTEGER, PARAMETER :: mes = 5
REAL(KIND=8) :: oi
REAL, PARAMETER :: ola = 4.0
REAL, PARAMETER :: pi = 3.141593
REAL, DIMENSION(4) :: a1
REAL, DIMENSION(3,3) :: b1
DOUBLE PRECISION :: dupla
CHARACTER(LEN=10) :: primeiro, ultimo
CHARACTER(10) :: primeiro = Meu nome
CHARACTER :: meio_escuro
LOGICAL :: claro
LOGICAL :: escuro = .FALSE.
COMPLEX :: nao
COMPLEX, DIMENSION(256) :: aqui
. . .
END
Inicialmente, como mencionado, os dois pontos (::) so facultativos quando no inicializamos a variveis, caso da linha 1. Assim, seriam necessrios somente nas linhas 3, 4, 6,
7, 12 e 15, mas uma boa prtica de programao coloc-los. Como vimos anteriormente,
sempre bom inicializarmos as variveis, para evitar que venham carregadas de algum lixo da
memria.
As variveis a1 e b1 so variveis compostas ou simplesmente arrays, i.e., vetores ou
matrizes, como demonstra o atributo DIMENSION. Estes tipos de variveis sero estudadas
no Captulo 4, na pgina 79. No primeiro caso, um vetor de tamanho 4 e, no segundo, uma
matriz 3 3. Nestes dois exemplos, informado ao processador que ele deve reservar na
sua memria um espao para armazenar as arrays a1 e b1. Esta uma alocao esttica de
memria, ou seja, do incio at o fim da execuo do programa este espao de memria est
reservado para este procedimento, mesmo que somente sejam usadas no incio do programa.
Mais adiante, veremos como alocar memria dinamicamente pelo comando ALLOCATABLE,
que ser estudada no Captulo 5, na pgina 91.
Outra considerao com relao ao atributo KIND, na linha 5, que especifica o tipo
de preciso desejada. Na ausncia assumido como preciso simples, que seria (KIND=4),
em que o algarismo 4 indica a preciso simples. Assim, para obtermos preciso dupla
necessrio acrescentar o atributo (KIND=8), em que o algarismo 8 indica a dupla preciso.
Na declarao permitido omitir a palavra-chave KIND=, podendo assim a declarao ser
fortran
95
fortran
95
30
escrita como segue

REAL(8) :: dupla
A declarao da linha 10, DOUBLE PRECISION, ser considerada obsoleta em breve.
importante, ento, substitu-la por
REAL(KIND=8) :: dupla
que tem o mesmo significado.
Na declarao da linha 11 o atributo LEN=10 indica o tamanho mximo que o caracter
pode assumir. Aqui tambm pode ser omitido a palavra-chave LEN= sem perda de significado, exemplificado na linha seguinte. Por curiosidade, a palavra-chave LEN vem da palavra
em ingls length que significa comprimento.
1.7
OS PROCEDIMENTOS INTRNSECOS
H tarefas que so executadas com frequncia quando trabalhamos no computador,
por exemplo, quando efetuamos clculos podemos utilizar seguidamente o cosseno de um
ngulo ou at mesmo o logaritmo ou a raiz quadrada de um nmero real. O Fortran oferece com muita eficincia um conjunto de procedimentos intrnsecos, que fazem parte do
ncleo do compilador. O Fortran 95 tem mais de 130 procedimentos intrnsecos, divididos
em diferentes classes:
Elementares: so os procedimentos matemticos, numricos, de manipulao de caracteres e de bits;
Consulta: que relatam ou retornam o estado de determinado procedimento, como por

exemplo, se a alocao de memria ou a leitura de um dado foi um sucesso ou no;
Transformao: procedimento que transforma de um estado para outro, como por exemplo, a converso de um nmero real em inteiro ou vice-versa.
Mistos: que incluem rotinas relativas ao processador e ao tempo, como por exemplo,
DATE_AND_TIME.
No nos preocuparemos em mostrar todos e nem em apresentar na classificao feita

acima. Alguns desses procedimentos sero vistos a seguir, especialmente os relativos a funes matemticas e de transformao numrica. Outros, referentes a caracteres, sero estudados na pgina 36.
1.7.1
As Funes Matemticas Intrnsecas
Como ocorre numa simples calculadora de mo, o Fortran 95 oferece quase uma centena de
funes pr-definidas ou conhecidas por funes intrnsecas, ou procedimentos intrnsecos, tais
como cosseno e seno de um ngulo. Algumas funes esto apresentadas na tabela 1.1, nas
quais so indicados os possveis argumentos de cada uma das funes.
31
Tabela 1.1 Alguns procedimentos intrnsecos (matemticos) do Fortran 95.

Instruo
Funo
Argumento
ACOS(x)
ASIN(x)
ATAN(x)
ATAN2(y,x)
COS(x)
SIN(x)
TAN(x)
EXP(x)
LOG(x)
LOG10(x)
ABS(x)
MOD(x,y)
R
R
R
R
RC
RC
R
R
RC
R
IRC
IR
arccos(x)
arcseno(x)
arctag(x) ou arctg(x)
arctag(y/x) ou arctg(y/x)
cos(x)
seno(x)
tag(x) ou tg(x)
ex
ln(x)
log(x)
|x| (mdulo de x)
x/y (resto da diviso). o resultado de x INT(x/y)*y. Ex.:
MOD(3,2) 1 e MOD(2,-3) 2. Para reais: MOD(4.5,1.5) 0.0 e,
MOD(5.0,1.5) 0.5, ou seja, deu exato 3.0 e para completar o 5.0
necessrio 0.5.
SQRT(x)
DIM(x,y)
RC
IR
MAX(x1,x2,...)
IR
fornece o maior valor entre os argumentos. Deve ter no mnimo 2

argumentos. Ex.: MAX(2,5,0) 5.
MIN(x1,x2,...)
IR
fornece o menor valor entre os argumentos. Deve ter no mnimo 2

argumentos. Ex.: MIN(2,5,0) 0.
fornece a diferena positiva. Se X > Y, ento DIM(x,y) = X-Y. Se

Y > X e o resultado negativo, ento DIM(x,y) = 0.
Ex.: DIM(5,3) 2 e DIM(3,5) 0. E DIM(4.5,2.5) 2.0.
argumento em radianos. argumento > zero. argumento 0.

Conveno para o Argumento: I: Inteiro, R: Real de simples ou dupla preciso, RS: Real de preciso simples,
RD: Real de dupla preciso, C: Complexo.
Na sequncia, um cdigo exemplifica o uso de funes intrnsecas do Fortran. Foram

utilizadas duas funes, o COS, que fornece o cosseno do ngulo (dado em radianos) e, a
funo ABS, que retm o sinal de um nmero inteiro ou real, isto , fornece o valor numrico
sem o sinal, conhecido como absoluto do nmero.
Programa 1.5 Exemplo de uso de funes intrnsecas do Fortran.
1
2
3
4
5
6
7
8
9
10
11
PROGRAM uso_funcoes
IMPLICIT NONE
! Exemplo do uso de funcoes intrinsecas
! Autor: Gilberto Orengo (e-mail: orengo@orengonline.com)
REAL :: pi,alfa,theta,f,fx,modulo
pi = 3.14159265
WRITE(*,*) "Digite o valor do angulo (em graus):"
READ(*,*)alfa
theta = (alfa*pi)/180.0 ! Converte p/radianos
WRITE(*,*)"Digite o valor da Forca (em Newtons):"
READ(*,*)f
32
12
13
14
15
fx = f*COS(theta)
modulo = ABS(fx)
WRITE(*,*)"A Forca no eixo x, em modulo, eh: ", modulo
END PROGRAM uso_funcoes
H casos que ser necessrio utilizar as funes intrnsecas para obter outras. Por exemplo, no caso de logaritmos em outras bases usa-se a mudana de base pela relao:
loga (x) =
log(x)
log(a)
no Fortran
LOG10(x)/LOG10(a)
H funes intrnsecas que determinam relaes entre Inteiros, Reais e Complexos, descritas na tabela 1.2 , que tambm sero importantes no decorrer do livro.
Tabela 1.2 Algumas funes intrnsecas para manipulao de inteiros e reais.
Instruo
Argumento
REAL(x)
I RD C
Converte um nmero inteiro, real de dupla preciso e complexos

em um nmero real de preciso simples. Ex.: REAL(7) resulta em
7.00000000.
Funo
DBLE(x)
I RS C
Converte um nmero inteiro, real de preciso simples e complexo

em um nmero real de preciso dupla. Ex.: DBLE(7) resulta em
7.000000000000000.
INT(x)
RC
Converte um nmero real de preciso simples ou dupla e complexo

em um nmero inteiro por meio de truncamento. Ex.: INT(5.9) resulta em 5, e INT(3.5) resulta em 3. INT(CMPLX(2.4,1.7))
resulta em 2.
NINT(x)
RC
Converte um nmero real em um nmero inteiro por meio de arredondamento; em que x um real. Ex.: NINT(5.9) resulta em 6, e
INT(2.4) resulta em 2.
CMPLX(x,y)
IR
Converte um nmero real ou inteiro(s) em um nmero complexo;

em que x um real. Ex.: CMPLX(5) resulta em (5.0,0.0), e
CMPLX(2.4,3.7) resulta em (2.4,3.7)
CEILING(x)
FLOOR(x)
fornece o menor inteiro maior ou igual ao real x.

Ex.: CEILING(3.15) 4 e CEILING(-3.15) -3.
fornece o maior inteiro menor ou igual ao real x.
Ex.: FLOOR(3.15) 3 e FLOOR(-3.15) -4.
Conveno para o Argumento: I: Inteiro, R: Real de simples ou dupla preciso, RS: Real de preciso simples,
RD: Real de dupla preciso, C: Complexo.
Uma listagem completa das funes pr-definidas est disponvel no site

http://www.orengonline.com/fortran95/ ou no Manual de Referncia da Linguagem. Para o compilador G95, consulte o endereo eletrnico http://www.g95.org.
1.7.2
A Aritmtica com inteiros e reais
AS EXPRESSES ARITMTICAS
As expresses aritmticas so aquelas que apresentam como resultado um valor numrico
33
que pode ser um nmero inteiro ou real, dependendo dos operandos e operadores. Os operadores aritmticos esto descritos na tabela 1.3.
Tabela 1.3 Os operadores aritmticos disponveis no Fortran 95.
Operadores Aritmticos
Operador binrio
*
/
+
Funo
multiplicao
diviso
soma ou adio
subtrao
potenciao
Exemplos
5*2; A*B
2/7; 8.5/3.1;
3 + 5; A + J
5 1; x y
3**5 = 35
Operador unrio
+
Funo
indica nmero positivo
indica nmero negativo
Exemplos
+3
1
M/N
importante ressaltar alguns pontos na aritmtica de inteiros e reais:

a) Dois operadores no podem estar lado-a-lado. Por exemplo: 2*7 ilegal. Na programao em Fortran escrito como segue: 2*(7). Da mesma forma devemos ter
cuidado com a exponenciao. O correto 2**(3) e no 2**3.
b) A multiplicao implcita no aceita no Fortran, isto , a expresso z(xy) deve ser
escrita como z*(xy).
c) A radiciao pode ser transformada numa potenciao, por exemplo, 6 (6)1/2 , que
na linguagem Fortran fica 6**(1./2.). Deve-se tomar muito cuidado nesta operao
e este assunto tratado com mais detalhes na pgina 35.
A ordem de prioridades nas operaes aritmticas, na linguagem Fortran :
1 Operaes que esto no interior de parnteses, iniciando sempre dos parnteses mais
internos para os mais externos. Os parnteses determinaram a ordem da operao.
Ento, use sem restries os parnteses para evindeciar a ordem das operaes.
2 Todas as potenciaes (**), da direita para a esquerda, e depois as radiciaes (SQRT).
3 Todas as multiplicaes (*) e divises (/), partindo da esquerda para a direita.
4 Todas as adies (+) e subtraes (), realizando as operaes da esquerda para a direita.
A ARITMTICA DOS INTEIROS

A operao entre nmeros inteiros resulta em nmeros inteiros. Desta forma deveremos ter
cuidado com algumas operaes, em especial com a diviso. Vejamos os casos abaixo.
34
1
=0
2
2
=1
2
3
=1
2
4
=2
2
5
=2
2
6
=3
2
7
=3
2
8
=4
2
9
=4
2
5
=1
4
7
=1
4
1
=0
3
Baseado nos resultados devemos ter cautela quando formos utilizar estas operaes de
diviso entre inteiros, porque, por exemplo na primeira diviso,
1
= 0 6= 0.5 ,
2
sendo este ltimo o resultado da diviso entre reais. Lembre-se que os nmeros reais so
tratados com ponto decimal e no com a vrgula, como estamos habituados.
Sugere-se que utilize os nmeros inteiros nos procedimentos estritamente necessrios,
por exemplo, em contadores de repeties ou ainda em ndices de variveis compostas, como
matrizes e vetores.
A ARITMTICA DOS REAIS
As mesmas operaes realizadas anteriormente com inteiros, entre reais resultar em:
1.0
= 0.5
2.0
2.
= 1.
2.
3.
= 1.5
2.
4.
= 2.
2.
5.
= 2.5
2.
7.
= 3.5
2.
8.
= 4.
2.
9.
= 4.5
2.
5.
= 1.25
4.
7
= 1.75
4
1.
= 0.3333333
3.
(Preciso simples)
1.
= 0.333333333333333
3.
6.
= 3.
2.
(Preciso dupla)
Observe que as duas ltimas divises se diferenciam pela a preciso. Um cuidado necessrio com as operaes matemticas que estamos acostumados a realizar no dia-a-dia,
tais como
3.0*(1.0/3.0) 6= 1.0
e,
2.0*(1.0/2.0) = 1.0
Esta diferena est na forma como o computador manipula os dados, que dependem da
preciso estabelecida. Assim, quando formos realizar testes de igualdades devemos ter muito
cuidado.
A ARITMTICA MISTA: ENTRE INTEIROS E REAIS
Quando misturamos operaes de reais com inteiros devemos ter cuidado extremo. Vejamos
o porqu? Observe as seguintes operaes.
35
1)
2)
3)
4)
5)
2 +
2.
2 +
2 +
2.
1/2
+ 1/2
1./2
1/2.
+ 1./2.
resulta em:
resulta em:
resulta em:
resulta em:
resulta em:
2
2.
2.5
2.5
2.5
A primeira expresso somente entre inteiros e no h novidade, porque o resultado

ser um inteiro. A ltima tambm no tem novidade, porque o resultado ser um real, porque todos os termos so reais. A partir da segunda expresso, at a quarta, temos operaes
mistas. O resultado de uma operao mista, entre inteiros e reais, sempre ser real. Vejamos
como isso ocorre, na seguinte sequncia, para a terceira expresso:
2 + 1./2
2 + 1./2.
= 2. + .5
2 + .5
2.5
Cada termo resolvido separadamente. Primeiro, pela hierarquia, resolve-se a diviso. Como
tem uma operao envolvendo um inteiro e um real, inicialmente o Fortran converte o inteiro
para real. A seguir a operao de diviso realizada. No prximo passo novamente h o envolvimento entre inteiro e real. Novamente, primeiro o Fortran converte o inteiro para real,
para finalmente fornecer o resultado em real.
Outro cuidado quanto ao envolvimento de operaes mistas com exponenciao. Por
exemplo, seja 61/2 , que na linguagem Fortran fica 6**(1./2.). Deve-se tomar muito cuidado nesta operao, porque numa potenciao o expoente sempre inteiro. Assim, neste
caso o expoente no pode ser nulo, j que 1/2 = 0, na aritmtica de inteiros. Ento preciso
fazer uma diviso por reais. Quando o expoente fracionrio a operao substituida por:
ab = eb ln a , em que b real
61./2. = e1./2. ln(6.) ,
sendo que a base inteira foi convertida para real e passou como argumento do logaritmo
natural. Ento, o cuidado est na base que no poder ser negativa, porque o logaritmo de
nmero negativo no definido.
Finalmente, um ltimo cuidado embora no tem nada a ver com operaes mistas
importante salientar. A potenciao sempre ser realizada da direita para a esquerda, assim
2
(34 ) = 38 = 6561 ,
diferente de
34 = 316 = 43046721 .
Os resultados anteriores no contm pontos decimais porque so valores inteiros.
1.7.3
A Manipulao de Caracteres
Um conjunto de caracteres agrupados (string) representa uma palavra. A posio que cada
caracter (carter) ocupa neste agrupamento determinar o significado da palavra. No so
aceitos caracteres acentuados (, , , , ...) e caracteres especiais (, , , ...).
Os computadores somente entendem nmeros, assim um cdigo ASCII a representao numrica dos caracteres tais como a ou @. A tabela ASCII possui 256 posies e contm tambm caracteres acentuados, para contemplar a lngua latina (Portugus, Espanhol,
Italiano, etc).
36
Algumas funes para manipular caracteres so descritas a seguir.

LEN(x) = retorna o nmero (inteiro) de caracteres que compem um conjunto de caracteres (palavra ou string), em que x uma palavra escrita entre aspas (simples ou
dupla).
Exemplo: LEN(mae) resultado = 3.
Exemplo de uso em um programa:
Programa 1.6 O uso da funo LEN.
1
2
3
4
5
6
7
8
PROGRAM uso_len
IMPLICIT NONE
CHARACTER(LEN=6) :: nome
INTEGER :: a
nome = fisica
a = LEN(nome)
WRITE(*,*)"Tamanho da palavra = ", a
END PROGRAM uso_len
A sada na tela do monitor, ser: Tamanho da palavra = 6
LEN_TRIM(x) = retorna o nmero (inteiro) de caracteres sem os espaos em branco que

compem um conjunto de caracteres (palavra ou string), em que x uma palavra
escrita entre aspas (simples ou dupla).
Exemplo: LEN_TRIM(mae e pai) resultado = 7.
Se fosse usada a funo LEN(mae e pai) o resultado seria igual a 9.
ACHAR(i) = retorna o caracter da tabela ASCII correspondente ao inteiro i.
Exemplo: ACHAR(65) resulta na letra A, e ACHAR(97) resulta na letra a
Exemplo do uso em um programa:
Programa 1.7 O uso da funo ACHAR.
1
2
3
4
5
6
7
8
9
10
PROGRAM uso_achar
CHARACTER :: letras
INTEGER :: posicao
WRITE(*,*)"Digite um inteiro para obter o&
& caracter ASCII:"
WRITE(*,*)"(Nao esqueca que eh entre 0 e 256)"
READ(*,*) posicao
letras = ACHAR(posicao)
WRITE(*,*)"O caracter eh: ", letras
END PROGRAM uso_achar
Se for digitado 110, a sada na tela do monitor ser: O caracter eh: n, ou se
for digitado 56, a sada na tela do monitor ser: O caracter eh: 8. Observe
que neste ltimo retornado pela funo ACHAR(56) o caracter 8 e no o algarismo
8. Desta forma no podemos oper-lo aritmeticamente.
37
IACHAR(x) = retorna um nmero inteiro, que indica a posio do caracter x na tabela

ASCII, em que x deve estar entre aspas (simples ou duplas). Se esta entrada for
requisitada por intermdio de uma leitura (pelo comando READ), no so usadas
aspas, pois ser armazenada em uma varivel.
Exemplo: IACHAR(b) resulta no inteiro 98.
Exemplo em um programa:
Programa 1.8 O uso da funo IACHAR.
1
2
3
4
5
6
7
8
9
PROGRAM uso_iachar
CHARACTER :: letra
INTEGER :: posicao
WRITE(*,*)"Digite um caracter da tabela ASCII:"
READ(*,(A))letra
posicao = IACHAR(letra)
WRITE(*,*) "A posicao na tabela ASCII eh: ",&
posicao
END PROGRAM uso_iachar
Se for digitado o caracter s, a sada na tela do monitor ser: A posicao na tabela
ASCII eh: 115. Este resultado poder ser manipulado aritmeticamente.
CONSIDERAES IMPORTANTES:
possvel retirar ou retornar parte de uma palavra (string). Por exemplo, seja a string
pessoa. Podemos retirar somente o conjunto sso. Isto possvel somente com
a utilizao de variveis que armazenem caracteres. Vejamos como isto funciona por
intermdio do seguinte programa.
Programa 1.9 Retorna parte de uma string.
1
2
3
4
5
6
7
8
9
PROGRAM parte_de_char
CHARACTER(LEN=20) :: total
CHARACTER(LEN=3) :: parte
WRITE(*,*)"Digite uma palavra, com ate &
& 20 posicoes:"
READ(*,*)total
parte = total(3:5)
WRITE(*,*) "A parte da palavra digitada eh: ", parte
END PROGRAM parte_de_char
Assim, se for digitado a palavra pessoa, a resposta ser:
A parte da palavra digitada eh:
sso
Podemos comparar caracteres da tabela ASCII. A comparao ser utilizando as operaes lgicas de maior (>) e menor (<), por exemplo:
A > a = Falso (ou .FALSE.)
38
a > A = Verdadeiro (ou .TRUE.)

AAa > AAb = Falso (ou .FALSE.)
i > 9 = Verdadeiro (ou .TRUE.)
* > ) = Verdadeiro (ou .TRUE.)
Isto possvel porque na tabela ASCII os caracteres so conhecidos pelas suas posies
numricas (inteiros). Assim, por exemplo, todas as letras maisculas vem antes das
minsuculas, portanto as maisculas possuem um nmero de referncia menor do que
as minsculas.
O operador concatenao (//):

possvel combinar dois ou mais conjunto de caracteres (strings) para formar um conjunto maior. Esta operao feita pelo operador concatenao, a dupla barra para
esquerda, //. Vejamos o exemplo.
Programa 1.10 Exemplo de concatenao de strings.
1
2
3
4
5
6
7
8
9
10
11
12
PROGRAM ex_conc
CHARACTER(LEN=15) :: total1
CHARACTER(LEN=7) :: total2
CHARACTER(LEN=9) :: parte1
CHARACTER(LEN=6) :: parte2
parte1 = Gilberto
parte2 = Orengo
total1 = parte1//parte2
total2 = parte1(1)//parte2
WRITE(*,*) "A primeira concatenacao eh: ", total1
WRITE(*,*) "A segunda concatenacao eh: ", total2
END PROGRAM ex_conc
Os resultados sero, respectivamente, Gilberto Orengo e GOrengo.
Desta forma, encerramos a apresentao dos elementos essenciais do Fortran 95. A

partir deste ponto possvel criar programas simples, sem que necessitem de tomadas de
deciso ou de processos de repetio, que veremos no Captulo 3, na pgina 63. Encerrando
este captulo veremos como encontrar e depurar erros de programao.
1.8
CORRIGINDO ERROS DEBUGGING
Ao criarmos um cdigo estamos sujeitos a erros, os quais podem ser de trs tipos: de
sintaxe, de tempo-de-execuo e de lgica. Infelizmente errar tambm um atributo inerente
a programao. O pargrafo abaixo, retirado do livro do Chapman [6], na pgina 70, ilustra
com primazia esta situao.
39
... existem duas coisas certas na vida, a morte e os impostos. Mas se trabalhamos com programao acrescente mais uma certeza nesta lista: se escrever um programa com nmero
de linhas significativos, ele apresenter erro na primeira execuo ...
Historicamente os erros de programao so conhecidos como bugs[N14] , e o processo de

localizao dos erros como debugging.
A maioria dos compiladores tem uma ferramenta anexa para depurar erros, que auxilia
na deteco de problemas de execuo do cdigo. Nos compiladores que dispem de interface grfica esta tarefa facilitada. Nos compiladores de linhas de comando, o depurador
de erros ativado por meio de opes de compilao. No Apndice ?? descrito o uso do
depurador de erros no compilador G95.
A seguir veremos os trs tipos de erros citados incialmente.
ERRO DE SINTAXE
O erro de sintaxe o mais simples e o prprio compilador identifica-o, indicando como um
erro de compilao. Este erro est relacionado com a escrita das instrues Fortran. So
exemplos de erro de sintaxe:
Programa 1.11 Exemplos de erros de sintaxes.
1
2
3
4
INTEGR :: b
b = 2
WRITE(*;*) b
END
=
=
Na primeira linha o erro est na escrita (sintaxe) da declarao de varivel do tipo inteiro, que escrita INTEGER e no INTEGR. Na terceira linha, o erro est na separao dos
argumentos da instruo WRITE que so separados por vrgula e no por ponto e vrgula. O
correto :
Programa 1.12 Correes dos erros de sintaxes.
1
2
3
4
INTEGER :: b
b = 2
WRITE(*,*) b
END
ERRO DE TEMPO-DE-EXECUO
o tipo de erro que ocorre na execuo do programa quando uma operao ilegal tentada.
Na maioria das vezes uma operao matemtica, por exemplo, uma diviso por zero. Ou
ainda, a atribuio de um caracter no lugar de um inteiro ou real, sendo este tambm um erro
de lgica. Quando este tipo de erro detectado a execuo abortada.
[N14] Bug
significa em ingls qualquer tipo de inseto. Os primeiros computadores de tamanhos de grandes salas
paravam os processamentos devido a insetos que se localizavam em seus dispositivos. Para retornar ao trabalho era
preciso retirar os insetos, ou seja, fazer um debugging. Assim, este termo foi mantido no meio acadmico e at hoje
utilizado para erro e procura de erros.
40
ERRO DE LGICA
O erro de lgica mais difcil de identificar, porque o programa compilado e executado
sem problemas, mas o resultado est errado. Neste caso o compilador no tem condies
de reconhecer e est ligado diretamente forma de programar. O compilador pode somente
identificar um erro de lgica que est ligada a declarao de variveis. Neste caso tambm
um erro de tempo-de-execuo. Por exemplo:
Programa 1.13 Exemplo de erro de lgica.
1
2
3
4
INTEGER :: b
READ(*,*) b
WRITE(*,*) b*2
END
Neste caso, a varivel b declarada como inteira e se for inserida, na linha 2, uma
informao diferente de um valor inteiro, por exemplo real, acusar um erro e abortar a
execuo do programa.
Outros erros de lgica so difceis de detectar, como por exemplo, a diviso por um
nmero prximo de zero que pode levar o programa a gerar resultados errados. Ou ainda, se
muitos arredondamentos so executados muitas vezes podem, tambm, levar a um erro de
resultado. Para estes e outros tipos de erros de lgica o que podemos fazer tomar algumas
precaues, as quais so:
Utilizar sempre a instruo IMPLICIT NONE, que obriga a declarao de todas as variveis do cdigo computacional;
Nas expresses aritmticas e/ou lgicas usar parentses para tornar claro a ordem de
execuo na expresso.
Inicializar todas as variveis. Assim se evita que alguma sujeira de memria contamine os clculos ou as manipulaes de dados.
Escrever todas as entradas de dados. Desta forma possvel visualizar que dados foram informados ao programa e, assim possibilita sua confirmao e se for o caso, sua
correo.
Uma prtica utilizada para encontrar possveis erros permear o cdigo com instrues
tipo WRITE(*,*)estou aqui 1, WRITE(*,*)estou aqui 2, ..., ou com
WRITE(*,*)<resultado1>, WRITE(*,*)<resultado2> e assim sucessivamente, para
termos certeza do fluxo de execuo do cdigo. Vejamos um exemplo. Imagine que parte de
um cdigo de 320 linhas precisa calcular a tangente de um ngulo, para cada n, que a soma
de n vezes a expresso
1
+ en ,
en
ou seja,
!
j
X
1
n
n vezes a tg
+e
,
en
n=1
em que j = 200 no nosso exemplo.
41
O programa abaixo reproduz parte do referido cdigo. Por este motivo no deveria
apresentar uma sada de valor, um WRITE, j que o mesmo utilizado no decorrer do cdigo
original e assim, no precisaria ser impresso neste ponto do cdigo. Mas foi acrescentado
uma sada antes da finalizao do programa, somente com fins didticos, para visualizarmos
que existem limitaes computacionais que devem ser observadas.
Programa 1.14 Exemplo de erros em cdigos computacionais.
1
2
3
4
5
132
133
134
135
136
137
138
320
PROGRAM teste_erro
IMPLICIT NONE
INTEGER :: i, j, m
REAL :: x, y, z
REAL, PARAMETER : pi=3.14159265
DO i = 1,200
! Inicia um loop com 200 repeticoes
x = 1./EXP(i) + EXP(i)
y = y + x
z = TAN(y)
theta = (y*180.0)/pi ! Converte angulo p/graus
END DO
! Finaliza o loop com 200 repeticoes
WRITE(*,*) theta,z ! Soh para fins didaticos
END PROGRAM teste_erro
Ao compilarmos o programa alguns erros sero detectados pelo compilador. O primeiro
erro ser o de sintaxe, porque foi esquecido os dois pontos (:) na declarao da varivel pi,
indicado pelo compilador, conforme mostra a figura 1.1. Relembrando, sempre que inicializarmos uma varivel na sua declarao obrigatrio o uso de dois dois pontos (::).
Com erro deste porte abortada a compilao. Portanto, os erros de lgica no aparecem. Mas cuidado, nem todos os erros de sintaxe so detectados nesta etapa. Por exemplo,
se por engano escrever TA no lugar de TAN, para a funo tangente, no aparecer nesta
primeira compilao. Quando for detectado, ser como erro de definio de funo.
Realizada esta correo, a colocao dos dois pontos (:), compila-se novamente. E a a
surpresa!!! Acompanhe a deteco dos erros de lgica na figura 1.2.
Perceba que o compilador procura auxiliar indicando o provvel tipo e posio do(s)
erro(s). Isto fica claro com a notao:
In file ex_erro.f90:7
x = 1./EXP(i) + EXP(i)
1
Error: Type of argument x in call exp at (1)
should be REAL(4), not INTEGER(4)
que indica o arquivo (ex_erro.f90) e a linha 7. Perceba ainda que o 1, abaixo do EXP(i),
indica a provvel posio do erro na linha. O provvel tipo de erro (Error:) est no tipo de
argumento da exponencial, que deve ser real de preciso simples, e no inteiro.
Neste caso foram dois tipos de erro, embora apaream trs na indicao do compilador.
O primeiro a respeito do argumento da exponencial, que espera um valor real e foi passado
42
Figura 1.1 No terminal do Linux: indicao do erro de sintaxe, apresentados

pelo compilador G95.
Figura 1.2 Indicao dos erros apresentados pelo compilador G95.
um inteiro. A correo feita utilizando a funo REAL(i), que converte o inteiro para
real. Observe que no possvel trocar a declarao da varivel i porque ela um contador
do loop DO, que ser estudado no Captulo 3, na pgina 63. E contador sempre inteiro.
O segundo erro, o indicado pelo compilador, decorrente do primeiro, porque esperado
ento que EXP(i) seja uma funo definida pelo usurio j que estaria recebendo um valor
inteiro. Mas, corrigido o primeiro erro, este deixa de existir. Comprove se verdadeira a
afirmaao !!! Para isto, corrija somente o primeiro erro e re-compile.
43
O segundo erro de lgica (ou terceiro indicado pelo compilador) a ausncia de declarao da varivel theta. Esta deteco foi possvel pela presena do IMPLICIT NONE na
segunda linha.
Corrigido, compilado e executado o resultado surpreendente:
+Inf NaN
No ocorreu o esperado, que eram resultados numricos. O +Inf significa overflow (+ infinito), ou seja, nmero muito grande, que ultrapassou o limite do expoente da potncia de
dez. O NaN significa Not-a-Number, isto , no um nmero.
Para identificar onde est o problema, foi acrescentado uma sada de informao, localizada no interior da estrutura de repetio DO. A sada utilizada foi:
WRITE(*,*)"O resultado da tangente de ",theta, "eh: ",z, &
"(No loop: ", i, ")"
O objetivo imprimir em cada passo (loop), o resultado parcial. Observe parte das 200 sadas:
O
O
O
O
O
O
O
resultado
resultado
resultado
resultado
resultado
resultado
resultado
da
da
da
da
da
da
da
tangente
tangente
tangente
tangente
tangente
tangente
tangente
de
de
de
de
de
de
de
1.0087063E+38 eh: -10.567177 (No loop: 83 )

2.741948E+38 eh: 2.4247808 (No loop: 84 )
+Inf eh: 2.221997 (No loop: 85 )
+Inf eh: 1.0551705 (No loop: 86 )
+Inf eh: 0.4865762 (No loop: 87 )
+Inf eh: 10.228403 (No loop: 88 )
+Inf eh: NaN (No loop: 89 )
No loop 85 j aparece o problema, que a extrapolao do limite do expoente da potncia de

dez. A correo neste caso depende do problema que est sendo resolvido. Uma possvel
soluo a troca para preciso dupla das variveis reais. Neste caso ser necessrio executar
novamente com a mesma sada provisria, para verificar se o problema foi contornado. Outra
possibilidade: se no necessrio realizar um loop com 200 repeties, pode-se alterar o loop
para DO i = 1,84.
O programa 1.14, corrigido, apresentado a seguir. As linhas que foram corrigidas esto
destacadas e as linhas 137 e 138 podem ser descartadas depois de resolvido o erro.
Programa 1.15 Programa 1.14 corrigido.
1
2
3
4
5
132
133
134
135
136
137
138
PROGRAM teste_erro
IMPLICIT NONE
INTEGER :: i, j, m
REAL :: x, y, z, theta
REAL, PARAMETER :: pi=3.14159265
=
=
DO i = 1,200
! Inicia um loop com 200 repeticoes
x = 1./EXP(REAL(i)) + EXP(REAL(i))
=
y = y + x
z = TAN(y)
theta = (y*180.0)/pi ! Converte angulo p/graus
WRITE(*,*)"O resultado da tangente de ",theta,&
"eh: ", z, "(No loop: ", i, ")"
44
140
END DO
WRITE(*,*) theta,z
320
END PROGRAM teste_erro
139
! Finaliza o loop com 200 repeticoes

! Soh para fins didaticos
AS SUJEIRAS DA MEMRIA
Em vrios momentos neste captulo foi mencionado sobre as sujeiras da memria. E ainda,
que as variveis sejam inicializadas para evitar erros, justamente por conterem valores indevidos anteriormente armazenados no endereamento de memria utilizado. Para verificar
na prtica, digite o programa abaixo, compile-o e execute-o.
Programa 1.16 Exemplo de erro devido a sujeiras da memria.
1
2
3
4
5
PROGRAM testa_sujeira_memoria
IMPLICIT NONE
INTEGER :: a, b, c
WRITE(*,*) a + b + c
END PROGRAM testa_sujeira_memoria
Provavelmente ters uma surpresa, porque nenhum valor foi atribudo as variveis a,
b e c e, assim, espera-se um valor nulo ou at mesmo um erro de execuo. Mas no o que
ocorre. No momento do fechamento desta edio, o valor obtido pela execuo do programa
no Windows foi 16384 e no Linux -1073664380. Se executarmos em outra ocasio, muito
provvel que o valor seja diferente, porque depender dos valores contidos na memria.
Ento, cuidado!!! Sugesto? sempre inicialize as variveis.
Mais informaes a respeito de procura e correo de erros de programao em Fortran
podem ser obtidas nos manuais dos compiladores Fortran, especialmente do compilador que
ser usado para testar os programas aqui apresentados e para os que sero solicitados nos
exerccios a seguir.
Em cada captulo, quando necessrio, um captulo sobre debugging ser escrito. Isto
demonstra a importncia de reconhecer erros e corrgi-los para que o cdigo de fato funcione
como esperamos.
importante para a verificao de aprendizado a prtica com exerccios e a soluo de

problemas. Perceba que h uma diferena entre soluo de problemas e prtica com exerccios. O
primeiro subentende que o segundo foi realizado exaustivamente. Estaremos mais preparados para resolver ou solucionar problemas se estivermos devidamente treinados. Portanto,
altamente recomendvel que faa os exerccios a seguir, bem como os disponveis no site
http://www.orengonline.com/fortran95/.
As respostas e comentrios a respeito dos exerccios encontram-se no referido endereo
eletrnico, em exerccios. E, para verificar se est pronto para resolver problemas, um conjunto
deles est disponvel em problemas, tambm no site acima indicado.
45
Para reflexo !!
S existem duas coisas infinitas: o universo e a estupidez
humana. E no estou muito seguro da primeira.
Albert Einstein
1879 1955
EXERCCIOS
1.1) Sejam as variveis a, b, c, d, e, f, g, que so inicializadas como segue:
a = 3. b = 2. c = 5. d = 4. e = 10. f = 2. g = 3.
Avalie os seguintes procedimentos:
a)
y = a*b+c*d+e/f**g
b) y = a*(b+c)*d+(e/f)**g
c)
y = a*(b+c)*(d+e)/f**g
Siga o exemplo de soluo:

a) - Expresso para clculo:
y = a*b+c*d+e/f**g
- Completando com os valores:
y = 3.*2.+5.*4.+10./2.**3.
- Calculando 2.**3.:
y = 3.*2.+5.*4.+10./8.
- Calculando as multiplicaes e divises,

da esquerda para a direita:
- Calculando as adies e o resultado final:
y = 6.
+5.*4.+10./8.
y = 6.
+20.
+10./8.
y = 6.
+20.
+1.25
y = 27.25
1.2) No Fortran, a operao entre inteiros e reais no uma boa prtica, pois o computador
converte o nmero inteiro em real e a seguir procede a operao. Desta forma, podemos
perder informaes nestas operaes. Informe, do ponto de vista do Fortran, qual ser
o resultado em cada uma das operaes abaixo.
a) 3/2
b) 3./2.
c) 3./2
d) 1 + 1/4
e) 1. + 1/4
f) 1 + 1./4
g) 2 + 6./4
1.3) O programa abaixo ser compilado? Justifique sua resposta.
46
1
2
3
4
5
6
7
8
9
PROGRAM exemplo1
IMPLICIT NONE
INTEGER :: i,j
INTEGER, PARAMETER :: k=4
i = k**2
j = i/k
k = i+j
WRITE(*,*)i,j,k
END PROGRAM exemplo1
1.4) Que valores sairo do programa abaixo? Tente antes de executar o programa no computador, calcular as sadas. (O assunto com respeito a INT e NINT. O INT retorna a
parte inteira de um real por truncamento e o NINT por arredondamento)
1
2
3
4
5
6
7
8
9
10
PROGRAM exemplo2
IMPLICIT NONE
INTEGER :: i1, i2, i3
REAL :: r1 = 2.4, r2
i1 = r1
i2 = INT(r1*i1)
i3 = NINT(r1*i1)
r2 = r1**i1
WRITE(*,*)i1, i2, i3, r1, r2
1.5) O programa abaixo tem o objetivo de calcular os comprimentos dos lados de um tringulo retngulo (A=adjacente e B=oposto), dados os valores da hipotenusa(C) e do
ngulo(). O programa ser executado? Se no, explique. Se sim, ele produzir resultados corretos? Explique. Caso necessite de alterao, o que voc modificaria ou
acrescentaria?
1
2
3
4
5
6
7
8
9
10
11
PROGRAM exemplo3
REAL :: a, b, c, theta
WRITE(*,*) Entre com o comprimento da hipotenusa C:
READ(*,*)c
WRITE(*,*) Entre com o valor do angulo THETA em graus:
READ(*,*)theta
a = c*COS(theta)
b = c*SIN(theta)
WRITE(*,*)O comprimento do lado adjacente eh:,a
WRITE(*,*)O comprimento do oposto eh:
,b
1.6) Que valores sairo, quando as seguintes instrues forem executadas?
1
2
3
4
5
6
7
8
9
10
47
PROGRAM exemplo4
INTEGER :: i
LOGICAL :: l
REAL :: a
a = 0.05
i = NINT(2.*3.141593/a)
l = i>100
a = a*(5/3)
WRITE(*,*)i, a, l
1.7) Escreva um programa em Fortran 95 que calcule o pagamento semanal de empregados

horistas. O programa dever perguntar ao usurio o valor pago por hora (por funcionrio) e o nmero de horas trabalhada na semana. O clculo deve se basear na seguinte
expresso
Total Pago = Valor da Hora Horas Trabalhadas
(1.1)
Finalmente, voc dever mostrar o valor pago total. Teste seu programa calculando o
valor pago semanalmente para uma pessoa que ganha R$ 7, 50 por hora e trabalha 39
horas.
1.8) A distncia entre dois pontos (x1 , y1 ) e (x2 , y2 ) no plano Cartesiano dado pela equao
p
d = (x1 x2 )2 + (y1 y2 )2
(1.2)
Escreva um programa em Fortran 90/95 para calcular a distncia entre quaisquer dois
pontos (x1 , y1 ) e (x2 , y2 ) especificados pelo usurio. Use boas prticas de programao
no seu programa. Calcule a distncia entre os pontos (2,3) e (8,-5).
1.9) Desenvolva um programa que fornecido, pelo usurio, um nmero entre 1000 e 9999,
separe e escreva os valores referentes ao milhar, a centena, a dezena e a unidade. Exemplo: no caso do nmero 7452, milhar: 7000; centena: 400; dezena: 50 e a unidade: 2.
1.10) O aumento dos funcionrios de uma fbrica calculado com base em 80% do IGP-M
acumulado no ano (ndice Geral de Preos do Mercado, da Fundao Getlio Vargas
FGV). Faa um programa que leia o nmero do funcionrio, o valor do IGP-M e o
salrio atual do funcionrio. A seguir calcule o aumento e o novo salrio. Escreva o
nmero do funcionrio, o aumento e o novo salrio. (Obs.: use os seguintes nomes s
variveis: nmero do funcionrio = nf; IGP-M = igpm; aumento do salrio = as; salrio atual =
satual; novo salrio = ns.)
1.11) O custo final ao consumidor de um carro novo a soma do custo de fbrica com a percentagem do distribuidor e dos impostos (aplicados ao custo de fbrica). Supondo que
a percentagem do distribuidor seja de 28% e os impostos de 45%, escreva um programa
que leia o custo de fbrica de um carro e escreva o custo final ao consumidor. (Obs.:
1) Use os seguintes nomes s variveis: custo de fbrica = cf; custo final ao consumidor = cfc;
percentagem do distribuidor = pd; impostos = pi. 2) Construa o programa com o mximo de
informaes ao usurio)
48
1.12) Escreva um programa que calcule a posio, velocidade e acelerao de um corpo sujeito ao movimento harmnico simples, baseado nas equaes abaixo. Para iniciar, use
= 0, n = 3.14159265, b = 2.5. Teste para um conjunto de valores de t.
posicao = x = b sin (nt + )
velocidade = v = nb cos (nt + )
aceleracao = a = n2 b sin (nt + )
CAPITULO
TRABALHANDO COM
ARQUIVOS ENTRADAS/SADAS
(I/O) DE DADOS
Para reflexo !!

2.1 Introduo . . . . . . . . . . . . . . . . . .
Arquivo . . . . . . . . . . . . . . . . .
2.2 A instruo WRITE . . . . . . . . . . . . .
2.3 A instruo READ . . . . . . . . . . . . . .
2.4 A instruo OPEN . . . . . . . . . . . . . .
2.5 A instruo CLOSE . . . . . . . . . . . . .
2.6 Formatando as sadas e/ou entradas (FORMAT)
Exerccios . . . . . . . . . . . . . . . . . . . .
41
42
42
43
45
46
48
52
Se um dia tiver que escolher entre o mundo e o amor...

Lembre-se: Se escolher o mundo, ficar sem o amor, mas
se escolher o amor, com ele conquistar o mundo!!
Albert Einstein
1879 1955
2.1
INTRODUO
As entradas e sadas de dados em Fortran so realizadas pelas unidades lgicas. Uma
unidade lgica :
- um nmero inteiro no negativo associado a um dispositivo fsico tal como uma unidade de disco (HD, disquete, CD,...), teclado, monitor ou uma impressora. A unidade
lgica conectada a um arquivo ou dispositivo pela instruo OPEN (ver Seo 2.4, na
pg. 53), exceto nos casos dos arquivos pr-conectados.
- um asterisco, *, indica o arquivo ou dispositivo padro (default), pr-conectado, de
entrada e de sada, usualmente o teclado e a tela do monitor, respectivamente. Leia a
nota da pgina 54.
- uma varivel tipo CHARACTER corresponde ao nome de um arquivo interno.
50
CAPTULO 2. TRABALHANDO COM ARQUIVOS ENTRADAS/SADAS (I/O) DE DADOS
ARQUIVO
O Fortran trata todos os dispositivos fsicos tais como unidades de discos, teclado, impressora, monitor ou arquivos internos como arquivo (file) ou arquivo externo. A estrutura do
arquivo determinada pelos dados (formatados ou no), o tipo de acesso ao arquivo e espao
(comprimento) para a informao.
O Fortran fornece instrues e procedimentos para manipular dados por leitura e escrita, conhecidas por entradas e sadas de dados, inclusive com o uso de arquivos internos.
Do ingls vem a denominao Input/Output, ou simplesmente I/O, para Entrada/Sada de
dados. Entre as instrues disponveis veremos somente algumas, a saber: WRITE e READ,
que so responsveis pela transferncia de dados, OPEN, que conecta as unidades lgicas aos
arquivos e FORMAT, que fornece informaes explcitas de formato dos dados. O objetivo
deste livro dar uma formao bsica, portanto no sero tratados assuntos relativos a tratamento de posicionamento interno num arquivo, tipos de arquivos, entre outros. Para um
avano no estudo da linguagem Fortran, consulte as referncias bibliogrficas, na pg. 135.
2.2
A INSTRUO WRITE
A instruo WRITE utilizada para transferir dados para o arquivo de sada (Output),
ou seja, escreve os resultados ou informaes de sada do programa.
A sintaxe :
WRITE([UNIT=]<unidade>,[FMT=]<formato>,[ADVANCE=<modo>])
em que:
[UNIT=]<unidade> : um argumento obrigatrio e indica a unidade lgica (dispositivo[N1] ) para a qual ser transferido o valor (ou informao) contido na memria. Como
unidade padro (default) utilizada a tela do monitor, e indicado por um asterisco (*).
Uma unidade lgica diferente da padro determinada pela instruo OPEN (ver Seo 2.4, na pg. 53). A palavra-chave UNIT opcional[N2] e na maioria dos programas
no utilizada.
[FMT=]<formato> : um argumento obrigatrio e especifica o(s) formato(s) para a escrita dos dados. Para instruir o compilador a escrever numa formatao livre (ou listadirigida) utilizado o asterisco (*), isto , o resultado ou a informao ser escrita da
forma como foi gerado, em acordo com a declarao da varivel que contm a informao. Uma sada com formatao livre no tem boa apresentao visual. Uma formatao
diferente da padro obtida pela instruo FORMAT, que ser descrita mais adiante (Seo 2.6, na pg. 56). A palavra-chave FMT opcional e no utilizada na maioria dos
programas.
[N1] Dispositivo significa algum meio fsico como por exemplo, tela do monitor, a impressora, um arquivo numa
unidade de disco seja magntica ou CD/DVD, o teclado, ou outro.
[N2] Neste livro, toda instruo ou argumento escrito entre colchetes ([ ... ]) considerado opcional.
51
ADVANCE=<modo> : argumento opcional, especifica se a prxima sada (ou entrada) deve

iniciar numa nova linha ou no. O padro (default), na ausncia do parmetro, <modo>
=YES, ou seja, a nova sada avanar para uma nova posio ou nova linha. Adotando
o argumento <modo> como NO no ocorrer avano para a nova linha ou posio de
escrita. Uma aplicao pode ser vista na pg. 52, no exemplo da instruo READ.
Vejamos o seguinte exemplo.
Programa 2.1 Exemplo de sada de dados.
1
2
3
4
5
6
7
8
9
10
PROGRAM saida
IMPLICIT NONE
INTEGER :: a=10, b=20, c=135
WRITE(*,*) a
OPEN(UNIT=10, FILE="saida1.txt")
WRITE(10,*) b
WRITE(10,200) c
200 FORMAT(I3)
CLOSE(10)
END PROGRAM saida
No primeiro WRITE, o contedo da varivel a ser escrito na tela do monitor e em
formato livre. No segundo, o resultado armazenado na varivel b ser escrito no arquivo
de nome saida1.txt, identificado pela unidade lgica 10, procedimento permitido pela instruo OPEN. J a outra sada de resultado, pela varivel c, tambm no arquivo anterior, mas
formatada pela instruo FORMAT, localizada no programa pelo rtulo nmero 200, que neste
caso instrui o compilador a imprimir um nmero (do tipo inteiro) com 3 algarismos. Como
exemplo, o nmero 135 poder ser impresso ajustadamente no espao designado. Quando
o nmero no couber nos espaos determinados pela formatao uma sequncia de asteriscos ser impressa no lugar do nmero ou da informao. A instruo CLOSE, que encerra a
atividade da unidade 10, estudada na pg. 54.
2.3
A INSTRUO READ
A instruo READ transfere dados de uma unidade de entrada (Input) para uma varivel,
isto , l dados que alimentaro com valores e/ou informaes o programa em Fortran.
A sintaxe :
READ([UNIT=]<unidade>,[FMT=]<formato>)
em que:
[UNIT=]<unidade> : a unidade lgica (dispositivo) da qual ser obtido o valor (ou informao). Como unidade padro utilizado o teclado e indicado por um asterisco (*).
Entenda-se por teclado, os dados digitados por este dispositivo. Uma unidade lgica diferente da padro determinada pela instruo OPEN. A palavra-chave UNIT opcional,
e no utilizada na maioria dos programas.
52
[FMT=]<formato> : especifica com que formato(s) a leitura dos dados realizada. Para
instruir o compilador a ler numa formatao livre (ou lista-direta) utilizado o asterisco
(*). Neste caso, a memria receber uma informao sem nenhum tipo de preocupao
com a editorao da informao. Uma formatao diferente da livre obtida pela instruo FORMAT, que ser descrita na Seo 2.6 (na pg. 56). A palavra-chave FMT opcional
e no utilizada na maioria dos programas.
O argumento ADVANCE apresentado na instruo WRITE tambm pode ser utilizado
aqui, com o mesmo significado.
Vejamos um exemplo:
Programa 2.2 Exemplo de entrada de dados.
1
2
3
4
5
6
7
8
9
10
11
12
PROGRAM leitura
IMPLICIT NONE
REAL :: a, b, c
WRITE(*,60,ADVANCE="NO")"Digite um numero real: "
READ(*,*) a
OPEN(UNIT=20, FILE="dados1.txt")
READ(20,*) b
READ(20,50) c
50 FORMAT(F5.2)
60 FORMAT(A)
CLOSE(20)
END PROGRAM leitura
No primeiro READ, o contedo da varivel a ser preenchido via teclado e em formato
livre. Utilizar o teclado significa digitar uma informao, compatvel com o tipo da declarao da varivel, e na sequncia teclar <ENTER>[N3] . Observe que no WRITE aplicado o
argumento ADVANCE, e a prxima instruo de leitura (ou de escrita) no avanar para a
prxima linha. Assim, na sequncia, o cursor ficar posicionado ao lado da sada anterior
aguardando a leitura da varivel a.
FALAR SOBRE O 60 format
No segundo READ, a varivel b receber um valor que est armazenado num arquivo
de nome dados1.txt, identificado pela unidade lgica 20, anteriormente habilitada pela instruo OPEN. J a outra entrada de informao, pela varivel c, tambm oriunda do arquivo
anterior, mas formatada pela instruo FORMAT, localizada no programa pelo rtulo nmero
50, que neste caso instrui o compilador a ler um nmero, do tipo real, com 5 espaos, sendo
dois para as casas decimais aps a vrgula. Neste caso, o nmero 56.50 caber ajustadamente,
pois tem 5 espaos (caracteres) e com duas casas decimais. Perceba que o ponto decimal faz
parte da contagem dos espaos disponveis. Quando o nmero no couber nos espaos determinados pela formatao, o compilador arredondar o nmero, fazendo-o se ajustar na
formatao determinada ou imprimir asteriscos.
[N3] Usaremos
a conveno <ENTER> para designar teclar ENTER.
53
CONSIDERAES ADICIONAIS SOBRE WRITE/READ

2.1) possvel ter mltiplas sadas e/ou entradas de dados, da seguinte forma:
WRITE(*,*) a, c, resultado
READ(*,*) b,g
nas quais, as variveis (separadas por vrgulas) a, c e resultado fornecem
sadas; e as variveis b e g recebem valores de entrada.
2.2) Para lermos uma informao do tipo CHARACTER necessrio alterar a instruo de
leitura da seguinte forma:
READ(*,(A)) b
em que o argumento (A) especifica a leitura de caracter, exigindo assim a declarao
da varivel b como segue
CHARACTER :: b
ou, por exemplo
CHARACTER(LEN=3) :: b
Nesta ltima declarao, a varivel armazenar um caracter de comprimento igual at
3 unidades.
2.4
A INSTRUO OPEN
Esta instruo conecta ou reconecta um arquivo externo a uma unidade lgica de entrada ou de sada. Vimos que os dispositivos padres de entrada e sada, na maioria dos
compiladores Fortran 95, so respectivamente, o teclado e a tela do monitor. A instruo
OPEN permite alterar o dispositivo de entrada e de sada, que realizada na seguinte sequncia: associa-se o nome de um arquivo externo a uma unidade lgica, que ser usada nas
instrues de entrada e sada de dados, e atribui-se um estado (status) ao arquivo.
A sintaxe :
OPEN([UNIT=]<nmero>, FILE="<nome_arq.>", [STATUS="<estado>"])
e deve estar localizada antes da unidade lgica ser utilizada. Os argumentos da instruo
so:
[UNIT=]<nmero> : o argumento que se refere a unidade lgica e ao seu respectivo arquivo de entrada/sada; UNIT uma palavra-chave e o <nmero> um nmero inteiro no negativo, sendo que o nico cuidado para no coincidir com o nmero adotado pelo compilador para os dispositivos padres, de entrada e sada. Neste sentido,
aconselha-se adotar numerao acima de 8. A palavra-chave UNIT= opcional.
54
FILE=<nome_arq.> : fornece o nome associado com a unidade lgica. importante

que o nome contenha uma extenso, por exemplo dados1.txt.
STATUS=<estado> : um argumento opcional e fornece o estado do arquivo, e <estado>
pode ser:
a) OLD : o arquivo j existe,
b) NEW : o arquivo no existe, e ser criado,
c) REPLACE : um novo arquivo ser aberto. Se o arquivo j existe os dados sero apagados, para ser re-utilizado,
d) STRATCH : o arquivo ser criado temporariamente, e aps o uso ser eliminado. Neste
caso o argumento FILE no pode ser especificado, isto , o arquivo no ter nome.
e) UNKNOWN : desconhecido.
Este o argumento padro por definio (default), na ausncia do STATUS.
Exemplos:
OPEN(UNIT=10, FILE="resultados.txt", STATUS="NEW")
OPEN(UNIT=20, FILE="dados1.txt", STATUS="OLD")
OPEN(50, FILE=entrada1.txt)
No primeiro exemplo, uma unidade lgica com o nmero 10 criada e cuja unidade fsica
(ou arquivo) de nome resultados.txt conter e/ou estar habilitado para armazenar valores.
Perceba que um arquivo novo, ou seja, ele ser criado na execuo do programa. Caso
o arquivo interno j exista, o compilador retornar uma mensagem de erro, e encerrar a
execuo. No segundo exemplo, a unidade lgica ser de nmero 20 e o arquivo dados1.txt
existente, caso contrrio o compilador acusar um erro de inexistncia do arquivo interno.
No ltimo caso, a unidade lgica a 50 e o arquivo entrada1.txt, mas observe que a palavrachave UNIT foi omitida, bem como o status e, portanto, considerado como desconhecido.
AS UNIDADES PR-CONECTADAS
Foi mencionado que a numerao adotada para a unidade lgica no pode ser qualquer.
Os compiladores designam nmeros inteiros para as suas unidades lgicas padro, chamadas de Unidades de Entrada/Sada Pr-conectadas. Por exemplo, a unidade lgica 5 est
conectada ao dispositivo padro de entrada, usualmente o teclado, e a unidade 6 para o
dispositivo de sada, usualmente a tela do monitor. Assim, nas instrues de entrada/sada
de dados o asterisco representa estas unidades
2.5
A INSTRUO CLOSE
Quando uma unidade lgica est conectada ao seu arquivo externo, ele permanece neste
estado at o sua desconexo, ou at que cesse a execuo do programa. Em outras palavras,
55
nesta situao um arquivo permanece aberto. Assim, aps o uso do arquivo importante
fech-lo para evitar erros indesejveis. A instruo CLOSE desconecta uma unidade lgica
do seu arquivo externo. Ou seja, fecha o acesso ao arquivo e libera o nmero da unidade
lgica de I/O associada a ela.
A sintaxe :
CLOSE([UNIT=]<nmero>)
em que:
<nmero> : o nmero da unidade lgica definida no argumento UNIT da instruo OPEN.
Podemos fechar vrios arquivos simultaneamente, bastando para isso informar as unidades separadas por vrgulas.
Exemplos:
CLOSE(10,12,20)
CLOSE(UNIT=11)
CLOSE(50)
Observe que no primeiro exemplo a instruo CLOSE encerra simultaneamente 3 unidades lgicas. Outro ponto importante que a palavra-chave UNIT opcional e s foi utilizada
no segundo exemplo.
Para a instruo OPEN h outros argumentos, que no sero tratados aqui, e aconselhvel verific-los nos livros indicados nas referncias bibliogrficas, na pg. 135.
Exemplos resolvidos:
1) Escreva um programa em Fortran 95 que leia um
valor inteiro via dispositivo padro, multiplique-o
por dez e escreva o resultado em um arquivo com
nome saida1.txt.
Soluo: Adotaremos como unidade de sada a 50, e as
variveis a e b, respectivamente, para entrada e sada
de dados. Assim, o cdigo abaixo resolve o nosso problema.
Digite-o, compile-o e execute-o.
PROGRAM open1
IMPLICIT NONE
INTEGER :: a,b
OPEN(UNIT=50,FILE="saida1.txt")
WRITE(*,*)"Digite um no. inteiro"
READ(*,*) a
b = a*10
WRITE(50,*)b
CLOSE(50)
END PROGRAM open1
2) Escreva um programa em Fortran 95 que leia um

valor inteiro armazenado num arquivo de nome
saida1.txt (do exemplo anterior), multiplique-o por
mil e escreva o resultado em um arquivo com nome
saida2.txt.
Soluo: Adotaremos como unidade de entrada a 60 e a de
sada a 61 e, as variveis a e b, respectivamente, para
entrada e sada de dados. Devemos lembrar que o arquivo
de leitura j existe e, portanto, o argumento STATUS
ter como parmetro OLD. O cdigo abaixo resolve o
problema. Digite-o, compile-o e execute-o. Observe o uso da
instruo & para quebra de linha no Fortran.
PROGRAM open2
IMPLICIT NONE
INTEGER :: a,b
OPEN(UNIT=60,FILE="saida1.txt",&
& STATUS="OLD")
OPEN(61,FILE="saida2.txt")
READ(60,*) a
b = a*1000
WRITE(61,*)b
CLOSE(60)
CLOSE(61)
END PROGRAM open2
56
Podemos atribuir unidade lgica uma varivel, conforme o exemplo abaixo, no qual a
varivel ue, cujo valor inteiro informado pelo usurio, substitui o inteiro no argumento
UNIT dos exemplos acima.
Programa 2.3 Exemplo do uso de unidades lgicas.
1
2
3
4
5
6
7
8
9
10
11
12
13
PROGRAM unidade1
IMPLICIT NONE
INTEGER :: a,b,ue
WRITE(*,*)"Digite um numero inteiro:"
READ(*,*) a
b = a*10
WRITE(*,*)"Informe o numero (>8) da unidade logica &
&de saida:"
READ(*,*) ue
OPEN(UNIT=ue,FILE="saida1.txt")
WRITE(ue,*)b
CLOSE(ue)
END PROGRAM unidade1
2.6
FORMATANDO AS SADAS E/OU ENTRADAS (FORMAT)
Nos exemplos anteriores utilizamos entradas e sadas de dados sem formatao, isto
, da maneira como foram gerados os dados (ou resultados) elas foram impressas, seja na
tela do monitor ou num arquivo. possvel converter a representao interna, como est na
memria, conforme a declarao da varivel, para uma representao externa, utilizando a
instruo no executvel FORMAT. Este comando simplesmente instrui o compilador que a
sada (ou entrada) de dado obedecer uma formatao estabelecida.
A sintaxe da instruo FORMAT :
<rtulo> FORMAT(<cdigo-chave>)
em que:
<rtulo> : um nmero inteiro associado a instruo FORMAT, o qual ser o nmero de
chamada por uma instruo READ e/ou WRITE. A instruo FORMAT pode ser posicionada em qualquer linha no programa, aps as declaraes de variveis.
<cdigo-chave> : especifica o(s) formato(s) adotado para entrada e/ou sada de dados,
baseado na tabela 2.1. Podem ser utilizados mais de um cdigo separados por vrgula.
At agora todas as sadas e entradas de dados foram realizadas sem preocupao com
o formato. A partir deste momento deveremos ter cuidado ao utilizar a instruo FORMAT.
Veremos alguns pontos importantes.
57
OS CDIGOS-CHAVE
Existe mais de uma dzia de espcies de formatao (cdigos-chave) em Fortran 95, mas
usaremos somente alguns, descrito na tabela 2.1. Para auxiliar na compreenso da tabela
temos que:
w:
a largura do campo (nmero de dgitos) destinado ao referido dado.

A largura do campo (w) inclui o nmero total de posies, inclusive o sinal e o ponto
decimal da mantissa, o smbolo E, o sinal (de + ou de ) e os dois dgitos do expoente
(ou os dgitos determinados para o expoente, e).;
d:
corresponde aos dgitos aps o ponto decimal espao (casas decimais da mantissa);
e:
os dgitos do expoente E;
n:
significa o nmero de vezes que a formatao ser utilizada, ou seja, indica uma repetio. Por exemplo, no caso de 3A8, significa que sero impressos ou lidos 3 variveis do
tipo CHARACTER de tamanho igual a 8 cada.
Tabela 2.1 Descrio de algumas formataes utilizadas na instruo FORMAT.
Cdigo-chave
Significado
nAw
Interpreta os prximos w caracteres como um conjunto

de caracteres (cdigo-chave A) de texto.
Interpreta os prximos w dgitos como um nmero inteiro (cdigo-chave I).
Interpreta os prximos w dgitos como um nmero real,
numa notao sem potncia de dez (cdigo-chave E),
com d casas aps o ponto decimal.
de preciso simples, numa notao com potncia de
dez (cdigo-chave E), com d casas aps o ponto decimal.
de preciso simples, numa notao cientfica de potncia de dez (cdigo-chave ES), com d casas aps o ponto
decimal.
de preciso dupla, numa notao com potncia de dez
(cdigo-chave D), com d casas aps o ponto decimal.
Fornece n espaos horizontais (cdigo-chave X).
o conhecido Tab: move a leitura/escrita para a coluna
c, em que c o nmero da coluna.
nIw
nFw.d
nEw.d[Ee]
nESw.d[Ee]
nDw.d[Ee]
nX
Tc
Mais informaes sobre os tipos de formatao (cdigos-chave) podem ser obtidas nas
referncias indicadas no final do livro.
Sempre que o tamanho da informao for menor que o espao reservado, a informao
ser escrita justificada direita e sero acrescentados espaos em branco antes, para com-
58
pletar o espao reservado. Quando a sada sem formatao o que determinar o espao
reservado ser a definio de preciso adotada. Por exemplo, um nmero inteiro de preciso
simples ter 11 espaos reservados para a sada ou leitura, j includo o sinal. O sinal positivo
(+) omitido.
O TAMANHO DO PAPEL DE IMPRESSO
Antes do computador enviar a informao para o dispositivo de sada, construdo uma
imagem de cada linha. A memria do computador que contm esta imagem chamada de
rea de armazenamento de dados temporrio (output buffer). A largura de cada linha igual
a 133 caracteres, sendo o primeiro espao destinado ao caracter de controle, que veremos a
seguir. Os demais 132 espaos so para armazenar a sada de dados. Assim, cada impresso
ou sada de informaes dividida em pginas, de tamanho aproximadamente igual a 37,8
cm para a largura e 27,9 cm para a altura. Estas dimenses esto relacionadas com os formulrios contnuos muito utilizados at o final do sculo passado. Cada pgina dividida
em linhas, e cada linha em 132 colunas, com um caracter por coluna. Para estas medidas, e
dependendo do nmero de linhas por polegada que a impressora imprime, correspondem
entre 60 e 72 linhas. As margens superior e inferior equivalem aproxidamente a 1,27 cm.
O CARACTER DE CONTROLE
Este item muito importante na sada de dados pelo WRITE. O primeiro caracter da imagem,
contida na rea de armazenamento de dados temporrio, conhecido como caracter de controle e especifica o espaamento vertical da sada. A tabela 2.2 apresenta as possibilidades e
as aes deste caracter de controle.
Tabela 2.2 Caracteres de controle da sada formatada.
Caracter de controle
Ao
1
<espao>
0
+
Avana para a prxima pgina

(Nova pgina)
Espaamento simples entre linhas
Espaamento duplo entre linhas
No h espaamento entre linhas.
Sobrescreve (escreve em cima da) a linha anterior
Se qualquer outro caracter for utilizado como caracter de controle resultar em espaamento simples entre linhas, como se fosse usado o espao em branco (<espao>).
Para evitar erros na sada, no esquea do caracter de controle. Por exemplo, a seguinte
instruo de sada
WRITE(*,100) a
100 FORMAT(I2)
imprimir um valor numrico inteiro de duas posies. Esta a inteno. Vejamos dois
possveis valores. Se for passado para a varivel a o valor 7, a sada ser exatamente 7,
justificada a direita. Mas se for passado o valor 71 o resultado ser 1, porque o primeiro
59
caracter destinado ao de controle, neste caso o 7 e foi assumido como espao em branco,
portanto o espaamento entre linhas ser simples. No caso anterior no ocorreu erro porque
o primeiro caracter foi um espao em branco, j que o nmero tinha somente um algarismo.
Ento muita ateno.
Alguns exemplos de formatao so apresentados a seguir.
Programa 2.4 Exemplo do uso de formatos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PROGRAM format1
IMPLICIT NONE
REAL :: a = 123.45, b =
WRITE(*,100) a
!
WRITE(*,200) a
!
WRITE(*,300) a
!
WRITE(*,400) a
!
WRITE(*,500) a
!
WRITE(*,600) a
!
WRITE(*,700) a,b,c !
100 FORMAT(0,E11.5)
200 FORMAT(0,F6.2)
300 FORMAT(1,E12.6)
400 FORMAT( ,E10.2)
500 FORMAT( ,E15.5E6)
600 FORMAT( ,ES10.2)
700 FORMAT(+,3ES10.2)
END PROGRAM format1
6789.10,
a saida:
a saida:
a saida:
a saida:
a saida:
a saida:
a saida:
c = 0.000778
0.12345E+03
123.45
0.123450E+03
0.12E+03
0.12345E+000003
1.23E+02
1.23E+02 6.79E+03
7.78E-04
Observe as sadas escritas como comentrio[N4] . Atente, especialmente para a segunda

formatao, que exatamente o nmero original. As demais alteram a forma de escrever e
no mudam o significado matemtico da varivel a, a no ser nas ltimas que reduzem a
preciso do valor. Na ltima, foram realizadas trs sadas com a mesma formatao, definida
no FORMAT de rtulo 700. Nesta utilizada a formatao em notao cientfica, e observe
o caso do nmero 6789.10, que arredondado para se ajustar ao espao determinado e, no
nmero 0.000778 os zeros so abandonados e ajustados no expoente da notao cientfica. As
duas primeiras sadas sairo na pgina corrente, com espaamento duplo entre linhas. Na
terceira sada, o caracter de controle instrui que o resultado seja escrito numa pgina nova.
Os demais sero escritos nesta mesma pgina com espaamento simples entre as linhas. A
ltima sada sobrescrever a anterior.
Mais informaes a respeito de formatao de sada/entrada de dados so obtidas nos
livros sobre Fortran, citados nas referncias bibliogrficas, na pg. 135.
Quando o nmero no se ajusta na formatao determinada, um conjunto de asteriscos
impresso no lugar do nmero ou da expresso. Veja o exemplo abaixo.
[N4] Lembrete: um comentrio em Fortran inserido pela instruo ! (sinal de exclamao) antes da sentena que
desejamos comentar. Pode aparecer em qualquer parte do programa.
60
Programa 2.5 Exemplo de formatao inadequada.

1
2
3
4
5
6
7
PROGRAM format2
IMPLICIT NONE
INTEGER :: a1 = 12345, a2 = 678
WRITE(*,100) a1
! a saida: ****
WRITE(*,100) a2
! a saida: 678
100 FORMAT( ,I4)
END PROGRAM format2
Na primeira sada os asteriscos substituiram o nmero 12345, porque o espao reservado para sua impresso menor que o tamanho (em espaos) do nmero. Na segunda
sada uma coluna em branco foi acrescentada antes do nmero 678 para completar o nmero
de casas da declarao formatada, j que ele menor que o espao reservado. Ou seja, sempre
que o nmero for menor que o espao reservado, o nmero ser escrito justificado direita.
As formataes podem ser utilizadas diretamente nas instrues READ e WRITE. Por
exemplo, as seguintes instrues
WRITE(*,100) a1, a2
READ(*,200) a3, a4
100 FORMAT( ,I3,2X,E10.2)
200 FORMAT(2I5)
podem ser substitudas por
WRITE(*,( ,I3,2X,E10.2)) a1, a2
READ(*,(2I5)) a3, a4
2.7
CORRIGINDO ERROS DEBUGGING
Quando utilizamos entradas e sadas formatadas via arquivo necessrio muita ateno. Veremos dois casos de posicionamento dos dados de entrada.
ENTRADA DE DADOS EM UMA NICA LINHA DE UM ARQUIVO
O programa abaixo recebe dados reais de um arquivo em uma nica entrada, pela instruo
READ, conforme uma formatao especfica.
Programa 2.6 Exemplo de erro devido a formatao inadequada.
1
2
3
4
5
6
7
PROGRAM format_real
IMPLICIT NONE
REAL :: a, b, c
OPEN(UNIT=10, FILE="dados.txt", STATUS="OLD")
WRITE(*,*) "Digite dois numeros reais para soma-los: "
READ(10,100) a, b ! Unica entrada
c = a + b
61
8
9
10
WRITE(*,100) c
100 FORMAT(F5.2)
END PROGRAM format_real
O arquivo dados.txt contm os seguintes valores, em que o smbolo
branco:
30.40
indica espao em
21.50
A sada ser:
50.60
A verificao de aprendizado pela prtica com exerccios e com a soluo de problemas. altamente recomendvel que faa os exerccios a seguir, bem como os disponveis no
site http://www.orengonline.com/fortran95/. Aps este treinamento estar apto a resolver problemas.
importante lembrar que este livro introdutrio e, portanto, no contm todas as capacidades mais avanadas das instrues Fortran. Para uma abordagem neste nvel aconselhase os livros listados nas referncias biblioigrficas.
62
EXERCCIOS
2.1) O que ser impresso nas seguintes instrues Fortran? Use a = 345 e b = 1.0020E6 e
c = 1.0001E6
a)
INTEGER :: a
WRITE(*,100) a
100 FORMAT(1,a = , I4.1)
b) WRITE(*,( , ES12.6)) b
c)
WRITE(*,( ,O resultado da diferenca entre ,ES14.6, e ,

ES14.6, eh: , ES14.6)) b,a,b-a
2.2) Qual a largura (w) mnima necessria para imprimir um valor real num formato de
notao com potncia de dez (E) e numa notao cientfica de potncia de dez (ES) com
5 bits significativos de preciso? Obs.: consulte a respeito de preciso numrica na pgina 22,
no Captulo 1.
2.3) Escreva um programa que leia dois valores reais de preciso simples de um arquivo
de nome entrada.txt e escreva a soma deles em um novo arquivo, j existente, de nome
saida.txt. Use a instruo FORMAT para os valores.
2.4)
CAPITULO
AS ESTRUTURAS DE CONTROLE
3.1 Introduo . . . . . . . . . . . . . . . . . .
3.1.1 Expresses Aritmticas . . . . . . .
3.1.2 Expresses Lgicas . . . . . . . . .
Operadores Relacionais . . . . . . .
Operadores Lgicos . . . . . . . . .
3.1.3 Hierarquia dos Operadores . . . . .
3.2 Estruturas com Deciso (ou Seleo) . . . .
3.2.1 Estrutura Condicional Simples
(IF...THEN) . . . . . . . . . . . .
3.2.2 Estrutura Condicional Composta
(IF...THEN...ELSE IF) . . . . .
3.2.3 O comando IF Lgico . . . . . . . .
3.2.4 A estrutura de seleo direta
(SELECT CASE...CASE) . . . . . .
3.3 Estruturas de Repetio (Loops) . . . . . .
49
50
50
50
51
52
53
3.3.1 A Estrutura de repetio DO...END DO

3.3.2 A
Estrutura
de
repetio
DO...IF...END DO
ou
DO
infinito . . . . . . . . . . . . . . . .
O uso do WHILE . . . . . . . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . .
58
58
60
60
Saudade (09/09/2004 - 11:00)

53
54
55
56
57
Eternidade: tanto faz

dia aps dia se faz
Saudade: esta faz
o tempo ser sagaz
Gilberto Orengo
1961
3.1
INTRODUO
Todos os programas vistos at o momento executam uma srie de procedimentos um
aps o outro numa ordem fixa. Estes so conhecidos como programas ou cdigos seqenciais
e so as formas mais simples de execuo de uma tarefa. Neles so lidos e processados
dados de entrada que, ao final imprimem o resultado, sem que em algum momento seja
preciso decidir sobre uma ou outra sequncia de execuo, ou ainda sem repetio de um
certo processo. Cdigos mais elaborados necessitaro de procedimentos que permitam o
controle na ordem ou no fluxo de execuo de procedimentos, como por exemplo, pulando
para outra parte do programa ou at mesmo para outra tarefa (subtarefa - SUBROUTINE e
FUNCTION, que sero estudadas adiante, na pg. 97).
Este tipo de controle, na estrutura do fluxo de execuo do programa, uma das caractersticas de uma linguagem estruturada, como o Fortran.
64
CAPTULO 3. AS ESTRUTURAS DE CONTROLE
As duas categorias de controle de procedimentos disponveis no Fortran, so:
TOMADAS DE DECISO (Desvios) ou ramificaes, permitem selecionar um desvio

para o fluxo de execuo do programa, em acordo com uma condio lgica. Veremos
as seguintes instrues de deciso:
IF...ELSE IF...ELSE...END DO, nas pginas 67 e 69,
IF lgico, na pgina 71,
SELECT CASE, na pgina 71;
PROCESSOS DE REPETIO (loops), instruem que uma parte do cdigo seja executada repetidamente, sob uma determinada condio. Veremos as seguintes instrues
de repetio:
DO...END DO, na pgina 73,
DO...IF...END DO (loop infinito), na pgina 74.
Para usarmos estas estruturas necessrio vermos inicialmente as expresses aritmticas e lgicas, nas quais so utilizados os operadores aritmticos, relacionais e lgicos, que
serviro de base para os testes de lgica no controle do fluxo de execuo do programa.
3.1.1
Expresses Aritmticas
Embora tenhamos visto as expresses aritmticas no Captulo 1, repetiremos aqui. As expresses aritmticas so aquelas que apresentam como resultado um valor numrico que pode
ser um nmero inteiro ou real, dependendo dos operandos e operadores. Os operadores
aritmticos esto descritos na Tabela 3.1.
Tabela 3.1 Os operadores aritmticos disponveis no Fortran 95.
Operador
*
/
+
Operadores Aritmticos
Funo
Exemplos
multiplicao
5*2; A*C
diviso
2/7; 8.5/3.1; H/B
soma ou adio
3 + 5; A + J
subtrao
5 1; A1 B
potenciao
3**5 = 35
65
3.1.2
Expresses Lgicas
Uma expresso lgica aquela que possui operadores lgicos e/ou relacionais.
OPERADORES RELACIONAIS
So utilizados para comparar dois valores de um mesmo tipo. Tais valores so representados por variveis (e constantes) ou expresses aritmticas (que contm operadores aritmticos). Os operadores relacionais so utilizados para a construo de equaes. O resultado
de uma operao relacional ser sempre um valor lgico, isto , um Verdadeiro/Verdade (V
ou .TRUE.) ou Falso/Falsidade (F ou .FALSE.). Os operadores relacionais adotados pelo
Fortran 95 esto descritos na Tabela 3.2. Observe a segunda coluna, que traz a forma obsoleta
do FORTRAN 77, mas que ainda vlida.
Tabela 3.2 Os operadores relacionais disponveis no Fortran 95.
Fortran 95
==
>
<
>=
<=
/=
Operadores Relacionais
FORTRAN 77
Funo
.EQ.
igual a
.GT.
maior que
.LT.
menor que
.GE.
maior ou igual a
.LE.
menor ou igual a
.NE.
diferente de
Como mencionado anteriormemte, o resultado um valor lgico. Por exemplo, na relao A + B = C, o resultado ser verdadeiro (V) ou falso (F) medida que o resultado da
expresso aritmtica A + B seja, respectivamente, igual ou diferente do contedo da varivel C.
OPERADORES LGICOS
So cinco (5) os operadores lgicos para a formao de outras proposies lgicas simples. Os
operadores esto descritos na Tabela 3.3, e as possibilidades de agrupamento esto descritos
na Tabela-verdade (Tabela 3.4) abaixo.
Tabela 3.3 Os operadores lgicos disponveis no Fortran 95.
Operadores Lgicos
Operador
Funo
.NOT.
negao
.AND.
conjuno
.OR.
disjuno
.EQV.
equivalncia
.NEQV.
no equivalncia
66
Tabela 3.4 Resultado de operaes lgicas - Tabela-verdade.

1 valor
F
F
V
F
F
V
V
F
F
V
V
F
V
F
Operador
.NOT.
.NOT.
.AND.
.AND.
.AND.
.OR.
.OR.
.OR.
.EQV.
.EQV.
.EQV.
.EQV.
.NEQV.
.NEQV.
.NEQV.
.NEQV.
2 valor
V
F
F
V
V
F
V
V
V
F
V
F
F
V
V
F
Resultado
F
V
F
F
V
F
V
V
V
V
F
F
V
V
F
F
Na operao com .AND. o resultado ser verdadeiro somente se ambos os valores relacionados forem verdadeiros (V). No caso do operador .OR. o que interessa que um dos
valores relacionados seja verdadeiro (V), para o resultado ser verdadeiro.
Em Fortran 95 os resultados de variveis lgicas para verdadeiro (V) e falso (F) so,
respectivamente, T e F, de .TRUE. e .FALSE.. importante salientar que a atribuio a
uma varivel lgica realizada pelos valores .TRUE. para verdadeiro e .FALSE. para falso.
Por exemplo:
LOGICAL :: a = .TRUE.
LOGICAL :: b = .FALSE.
Digite o programa, compile-o e execute-o para verificar o resultado.
Programa 3.1 Exemplo com operadores lgicos.
1
2
3
4
5
6
7
8
9
10
11
PROGRAM logica
IMPLICIT NONE
LOGICAL :: a, b, c=.TRUE.
a = 5>7; b = 5<7
IF(c) THEN
WRITE(*,*)".TRUE. ou verdadeiro"
ELSE
WRITE(*,*)".FALSE. ou falso"
END IF
WRITE(*,*)"Resultados de 5>7 e 5<7: ",a,b
END PROGRAM logica
67
3.1.3
Hierarquia dos Operadores
A ordem de prioridades entre os operadores utilizada na linguagem Fortran :

1 Operaes que esto no interior de parnteses, iniciando sempre dos parnteses mais
internos para os mais externos.
2 Todas as potenciaes (**) e depois as radiciaes (SQRT).
Obs.: a radiciao pode ser transformada numa potenciao, por exemplo, 6 (6)1/2 , que
na linguagem Fortran fica 6**(1./2.). Deve-se tomar muito cuidado nesta operao,
porque numa potenciao o expoente sempre inteiro. Assim, neste caso o expoente
para no ser nulo, j que 1/2 = 0, na aritmtica de inteiros, preciso fazer uma diviso
por reais. Quando isto for realizado a operao trocada por:
ab = eb ln a
61/2 = e1/2 ln(6) ,
e o cuidado est na base, que no poder ser negativa, porque o logaritmo de nmero
negativo no definido. A potenciao sempre ser realizada da direita para a es2
2
querda, (34 ) = 38 = 6561, mas cuidado com 34 = 316 = 43046721, que diferente
da anterior. Os resultados anteriores no contm pontos decimais porque so valores
inteiros.
3 Todas as multiplicaes (*) e divises (/), partindo da esquerda para a direita.
4 Todas as adies (+) e subtraes (), realizando as operaes da esquerda para a direita.
5 Todas as operaes relacionais (==, /=, >, <, >=, <=), iniciando sempre da esquerda
para a direita.
6 Todos os operadores .NOT., iniciando da esquerda para a direita.
7 Todos os operadores .AND., iniciando da esquerda para a direita.
8 Todos os operadores .OR. , iniciando da esquerda para a direita.
3.2
ESTRUTURAS COM DECISO (OU SELEO)
Estruturas com Deciso (ou Seleo) so procedimentos que permitem-nos selecionar e
executar sees especficas do cdigo (que sero chamadas blocos) ou at mesmo desviar para
outra parte do cdigo. Elas so as variaes da instruo IF, mais a estrutura SELECT CASE.
3.2.1
Estrutura Condicional Simples (IF...THEN)
A forma mais comum da instruo de deciso IF a estrutura condicional simples. Esta estrutura permite que um bloco de procedimentos seja executado se e somente se uma dada
expresso lgica for verdadeira.
68
A sua forma geral :

[<rtulo>:] IF (<condio lgica>) THEN
<procedimentos executveis>
END IF [<rtulo>]
em que:
IF :
especifica o incio da estrutura de deciso IF...END IF.
<rtulo> :
uma identificao opcional do bloco de deciso.
(<condio lgica>) : determina um teste lgico, que se for verdadeira ento (THEN)
executa os <procedimentos executveis>. Se for falsa, ento (THEN) o fluxo de
execuo desviado incondicionalmente para a linha seguinte ao END IF. A sequncia
de instrues IF...THEN obrigatoriamente escrita na mesma linha.
END IF : especifica o final do bloco de deciso <rtulo>. Como o rtulo opcional, no
comum utiliz-lo para um nico bloco.
INDENTAO
Observe a indentao utilizada na definio acima e no exemplo a seguir. Estes afastamentos facilitam a visualizao dos blocos ou estruturas no programa. Este estilo adotado ao
longo do livro e uma boa prtica de programao
No exemplo a seguir uma estrutura de deciso simples testa um nmero para identificar se
mpar ou no. Para a soluo necessrio utilizar a funo intrnseca MOD, que fornece o
resto da diviso entre nmeros inteiros. As funes intrnsecas ou procedimentos intrnsecos
esto descritos na pgina 31, no Captulo 1.
Programa 3.2 Exemplo de estrutura por deciso simples.
1
2
3
4
5
6
7
8
PROGRAM no_impar
INTEGER :: a
WRITE(*,*)"Digite um numero inteiro: "
READ(*,*) a
IF (MOD(a,2) == 1) THEN
WRITE(*,*)O numero digitado eh impar
END IF
END PROGRAM no_impar
Neste caso, se a expresso lgica (MOD(a,2) == 1) for verdadeira, uma instruo de
sada imprimir uma frase na tela do monitor indicando que o nmero digitado mpar. Se
for falsa, a execuo continua na linha seguinte ao END IF.
3.2.2
69
Estrutura Condicional Composta (IF...THEN...ELSE IF)
Na estrutura simples definida acima, o bloco de procedimentos abaixo do IF s ser executado se a condio lgica for verdadeira. Se a condio de controle for falsa, todos os
procedimentos do bloco sero ignorados e a execuo do programa seguir logo aps o END
IF.
Algumas vezes necessrio executar um conjunto de procedimentos se uma dada condio lgica for verdadeira e outro conjunto de procedimentos para outra condio lgica
verdadeira ou, at mesmo no caso da expresso lgica ser falsa. A estrutura condicional
composta fornece esta possibilidade e a sua forma geral, que utilizaremos nos nossos algoritmos, :
[<rtulo>:] IF (<condio lgica 1>) THEN
<procedimentos bloco 1>
ELSE IF (<condio lgica 2>) THEN
. . .
[ELSE IF (<condio lgica i>) THEN]
<procedimentos bloco i>
[ELSE]
<procedimento padro>
END IF [<rtulo>]
em que:
IF :
especifica o incio da estrutura de deciso IF...THEN...ELSE IF.
<rtulo> :
uma identificao opcional do bloco de deciso.
(<condio lgica>) : determina um teste lgico.

Vejamos como trabalha todo o bloco interno ao IF:
inicialmente, se a <condio lgica 1> for verdadeira ento (THEN) o programa executa os <procedimentos bloco 1> e imediatamente aps desviado para a primeira
linha aps o END IF. Se for falsa, a linha seguinte (ELSE IF (<condio lgica
2>) THEN) ser executada. Nesta linha, novamente um teste lgico realizado, e se for
verdadeiro os <procedimentos bloco 2> sero executados e na sequncia desviado para a primeira linha aps o END IF. Se for falsa, o prximo ELSE IF ser executado e assim sucessivamente.
Se nenhuma condio lgica anterior for verdadeira, ou por outras palavras, se todas as
i-simas condies lgicas forem falsas o procedimento padro (default), logo abaixo
o ELSE, ser executado.
END IF : especifica o final do bloco de deciso <rtulo>. Como o rtulo opcional, no
comum utiliz-lo para um nico bloco.
Observe que pelo menos um ELSE IF ou um ELSE necessrio para ser considerado uma
estrutura condicional composta.
No exemplo a seguir uma estrutura testa o discriminante de uma equao quadrtica
(b2 4ac), para clculo das razes, com o objetivo de identificar as razes.
70
Programa 3.3 Exemplo de estrutura por mltiplas decises.

1
2
3
4
5
6
7
8
9
10
11
12
13
PROGRAM raizes
REAL :: a, b, c
WRITE(*,*)"Digite os coeficientes da eq.: "
READ(*,*) a, b, c
IF ((b**2 - 4.0*a*c) < 0.0) THEN
WRITE(*,*)Raizes complexas
STOP
ELSE IF((b**2 - 4.0*a*c) == 0.0) THEN
WRITE(*,*) "A solucao tera 2 raizes e iguais"
ELSE
WRITE(*,*) "A solucao tera 2 raizes desiguais"
END IF
END PROGRAM raizes
Neste caso, se a expresso lgica (b**2 - 4*a*c < 0.0) for verdadeira, a execuo
do programa ser cancelada, devido ao STOP. Neste caso, no h interesse em calcular as
razes complexas. Se for falsa, a execuo continua na linha seguinte ao STOP e se (b**2 4*a*c == 0.0) uma frase ser impressa na tela do monitor e, a execuo desviada para
a primeira linha aps o END IF. Se for falsa, a condio default (do ELSE) ser executada e a
execuo continua na linha seguinte aps END IF.
A instruo STOP til quando necessitamos abortar a execuo em alguma parte do
programa que no seja o final. Neste caso, a execuo desviar para o END PROGRAM, encerrando o programa.
As estruturas de deciso podem ser aninhadas, ou seja, podem conter uma dentro da
outra, quantas forem necessrias, como por exemplo:
ext: IF (...) THEN
...
int1: IF (...) THEN
...
int2: IF (...) THEN
...
END IF int2
...
END IF int1
...
END IF ext
A estrutura ou bloco mais interno identificado pelo rtulo int2 e o mais externo por
ext. E, o bloco intermedirio identificado por int1. Nos casos de aninhamentos de
estruturas de deciso uma boa prtica de programao o uso dos rtulos, para tornar claro
que procedimentos so executados em cada bloco.
3.2.3
71
A instruo IF Lgico
uma forma alternativa da estrutura condicional IF e consiste de um nico procedimento

com estrutura:
IF (<expresso lgica>) <procedimento>
em que:
IF :
especifica o incio do comando lgico.
(<expresso lgica>) : determina um teste lgico, que se o resultado for verdadeiro

executa o <procedimento>. Caso contrrio, o fluxo de execuo continua na linha
seguinte.
Esta instruo utilizada nas estruturas de repetio sem contador fixo, nos chamados
loops infinitos, que veremos na pgina 74. O exemplo abaixo demonstra o uso dessa instruo.
Programa 3.4 Exemplo de deciso lgica em uma linha.
1
2
3
4
5
6
7
8
PROGRAM if_logico
IMPLICIT NONE
INTEGER :: a
WRITE(*,*)"Digite um numero inteiro: "
READ(*,*) a
IF(a >= 10) a = a + 25
WRITE(*,*)"O Resultado final eh: ",a
END PROGRAM if_logico
Neste caso, se for digitado um nmero maior ou igual a 10, o resultado final ser o valor
digitado somado de 25. Caso contrrio a sada ser igual a entrada.
3.2.4
A estrutura de seleo direta (SELECT CASE...CASE)
A estrutura SELECT CASE outra forma de ramificao numa tomada de deciso. Ela permite o programador selecionar um bloco especfico baseado no valor de uma nica varivel,
que poder ser inteira, caracter ou lgica. A forma geral que adotaremos para representar
esta estrutura :
SELECT CASE (<expresso>)
CASE(<seletor 1>)
CASE(<seletor 2>)
. . .
CASE(<seletor i>)
<procedimentos bloco i>
CASE DEFAULT
<procedimento padro>
END SELECT
72
em que:
SELECT CASE :
especifica o incio da estrutura de seleo direta.
<expresso> : a expresso que servir de chave de seleao. Dever ser do tipo inteiro
ou caracter ou lgico;
CASE :
a instruo que instruir o cdigo a testar o <seletor i>;
<seletor i> :
o valor ou intervalo que ser comparado com a <expresso>
CASE DEFAULT : uma instruo optativa. O objetivo ativ-la quando nenhum dos testes
anteriores realizados pela instruo CASE, for satisfeito.
O FUNCIONAMENTO:
Se o valor da expresso est dentro dos valores includos no seletor 1 ento os procedimentos do bloco 1 sero executados e, a seguir o fluxo de execuo desviado para o
END SELECT. De forma semelhante, se o valor de expresso estiver entre os valores do
seletor 2, os procedimentos do bloco 2 sero executados. A mesma idia se aplica aos demais outros casos desta estrutura. O CASE DEFAULT opcional, mas se estiver presente, s
ser executado se todos os seletor i anteriores forem falsos. Ainda, se o algoritmo no contiver o CASE DEFAULT e mesmo assim todos os seletor i anteriores forem falsos, nenhum
bloco da estrutura SELECT CASE ser executado.
O programa a seguir imprime mensagens conforme o valor da temperatura.
Programa 3.5 Exemplo de estrutura por seleo direta.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
PROGRAM clima_temp
INTEGER :: temp_c
WRITE(*,*) "Informe a temperatura ambiente, em Celsius"
READ(*,*) temp_c
SELECT CASE (temp_c)
CASE (:-1)
WRITE(*,*) "Hoje esta muito frio"
CASE (0)
WRITE(*,*) "Temperatura de gelo da agua"
CASE (1:20)
WRITE(*,*) "Hoje esta frio, mas suportavel"
CASE (21:25)
WRITE(*,*) "Hoje o clima esta agradavel"
CASE (26:35)
WRITE(*,*) "Hoje est quente"
CASE DEFAULT
WRITE(*,*) "Hoje o dia esta muito quente"
END SELECT
END PROGRAM clima_temp
O valor de temp_c controlar o fluxo do algoritmo. Se a temperatura for menor ou
igual a -1 (ou menor que 0), ento o primeiro bloco ser executado, isto , sair na tela do
monitor a informao Hoje esta muito frio, e o fluxo incondicionalmente desviado
73
para END SELECT. O bloco abandonado. Se no for o caso, isto , a temperatura for igual
a zero, ento o segundo bloco ser executado e no o primeiro, e novamente aps ser executado o procedimento do bloco, o fluxo desviado para o final do bloco. E, assim sucessivamente. Observe que os selecionadores (valores atribudos para comparao com temp_c)
no se superpemum valor de temperatura s pode aparecer uma e somente uma vez no
selecionador.
importante salientar que os <seletor i> podem assumir:
<valor_nico>
Executa o bloco se <valor_nico> = <expresso>
:<valor_mximo>
Executa o bloco para todos os valores de <expresso> menores ou igual a <valor_mximo>
<valor_mnimo>:
Executa o bloco para todos os valores de <expresso> maiores ou igual a <valor_mnimo>
<valor_mnimo>:<valor_mximo> Executa o bloco para todos os valores da

<expresso> entre <valor_mnimo> inclusive e
<valor_mximo> inclusive
3.3
ESTRUTURAS DE REPETIO (LOOPS)
Veremos dois tipos de estruturas de repetio: o DO...END DO e o DO...IF...
END DO, conhecido tambm por DO infinito. Em ambos a caractertisca principal repetir
procedimentos, conforme uma lgica estabelecida.
3.3.1
A Estrutura de repetio DO...END DO
A sua forma geral :

[<rtulo>:] DO <contador> = <valor_i>, <valor_f>, [<incremento>]
<procedimentos>
END DO [<rtulo>]
em que:
DO :
especifica o incio da repetio dos procedimentos internos ao bloco DO...END DO, e

inicia a execuo dos <procedimentos>.
<rtulo> :
uma identificao opcional da estrutura de repetio.
<contador> = <valor_i>, <valor_f>, [<incremento>] : o controle das repeties pela varivel de controle contador, sempre do tipo inteiro. Mais:
<valor_i> : um valor inteiro que determina o incio do contador.
<valor_f> : um valor inteiro que determina o final do contador, e assim o fim do bloco
de repetio.
74
<incremento> : um nmero que determina o salto na repetio. Por padro igual
a um, isto , se for omitido o valor da varivel <contador> ser acrescida de 1

a cada loop. Poder assumir valores negativos, para por exemplo, fazer regedir o
<contador>, desde que o <valor_i> seja maior que o <valor_f>.
Importante: estes trs valores podem ser substitudos por varivel, do tipo inteiro, desde
que incializadas antes do DO. Por exemplo:
INTEGER :: i, x=1, y=200, z=2
DO i = x,y,z
END DO : especifica o final do loop <rtulo>. Como o rtulo opcional, no comum
utiliz-lo para um nico bloco.
O FUNCIONAMENTO DO CONTROLE DAS REPETIES:
ao iniciar um DO a varivel <contador> recebe o <valor_i>, executa os procedimentos internos e ao encontrar o END DO retorna a linha inicial do bloco. Adiciona o <incremento>
varivel <contador> e testa se <valor_i> <valor_f>. Se verdadeiro executa novamente os procedimentos. Este processo se repete at que <valor_i> <valor_f> seja
falso, condio que desviar a execuo para a primeira linha aps o END DO.
ATENO COM OS CONTADORES
Se precisar utilizar o valor do <contador> depois do bloco DO, tenha cuidado, porque o
<contador> sair com o ltimo valor que no igual ao <valor_f>, porque foi acrescido
do <incremento> antes do teste lgico, para verificar se <valor_i> <valor_f>
3.3.2
fortran
95
fortran
95
A Estrutura de repetio DO...IF...END DO ou DO infinito
At o momento, todos os blocos de repetio (DO...END DO) so executados sabendo-se

previamente quantas vezes ser repetida uma dada tarefa. Mas, algumas vezes necessrio
executar uma tarefa no interior de um bloco de repetio sem sabermos quantas vezes a
mesma ser repetida. Isto muito comum, por exemplo, nos casos de busca de convergncia
num processo iterativo. Desta forma, internamente ao bloco de repetio que ser tomada
a deciso de abandon-lo. Quando isto ocorrer a estrutura DO...IF...END DO dever ser
usada, com a instruo de controle EXIT.
H uma outra situao na qual, devido a um controle lgico, somente parte dos procedimentos internos ao bloco sejam executados, mas que no abandone at que outro controle
lgico seja satisfeito. Neste caso, juntamente com o EXIT, usamos a instruo de controle
CYCLE.
A forma geral deste bloco de repetio :
[<rtulo>:] DO
[<procedimentos 1>]
IF (<condio lgica>) <instruo de controle> [<rtulo>]
[<procedimentos 2>]
END DO [<rtulo>]
75
em que:
DO :
especifica o incio da repetio infinita dos procedimentos internos ao bloco

DO...IF...END DO. Neste caso, se existirem, os <procedimentos 1> sero executados.
<rtulo> :
uma identificao opcional dada a estrutra de repetio.
IF (<condio lgica>) : determina um teste lgico, pela (condio lgica), que caso
seja verdadeira executa a <instruo de controle>. Se for falsa, o fluxo do bloco
continua na prxima linha, executando os <procedimentos 2>. No h restrio
ao nmero de testes lgicos, mas que exista pelo menos um, neste caso de sada da
estrutura de repetio. E, podem estar localizados em qualquer ponto no interior do
DO...IF...END DO.
<instruo de controle> :
pode ser:
EXIT : determina a sada da estrutra de repetio <rtulo>, em que o <rtulo> po-
der ser de outra estrutura de repetio, sempre, externa a atual. Esta rotulagem
opcional, portanto, no comum utiliz-la para um nico bloco.
Quando esta instruo de controle for executada o fluxo de execuo do bloco (e do
programa) transferido para a primeira linha aps o END DO. Observe que neste
caso os <procedimentos 2> no sero executados.
CYCLE : determina o retorno ao incio da estrutra de repetio <rtulo>, em que, no-
vamente, o <rtulo> poder ser de outra estrutura de repetio, sempre, externa a

atual.
END DO :
especifica o final do loop.
A estrutura, como consta no quadro acima, funciona da seguinte maneira, por exemplo,
com a instruo de controle EXIT:
1. ao entrar no DO os <procedimentos 1> sero executados, caso existam,
2. a seguir a instruo IF ser executada, e caso seja falsa os <procedimentos 2> sero
executados e,
3. na sequncia retorna a executar os <procedimentos 1> e a instruo IF. Este ciclo ser executado sucessivamente, at que saia do bloco DO, quando a <condio
lgica> for verdadeira, e neste caso, o ltimo loop os <procedimentos 2> no sero executados.
Os <procedimentos 1> e <procedimentos 2> so opcionais e o uso de um ou de outro,
ou ainda de ambos, depender das tarefas a serem executadas no programa.
Este tipo de estrutura tambm recebe o nome de loop infinito (repeties infinitas), porque se no existir uma condio de sada ou se a condio lgica para um EXIT nunca
for verdadeira ele permanecer indefinidamente neste processo repetitivo. Portanto, deve-se
ter muito cuidado no uso dessa estrutura de repetio.
76
O USO DO WHILE
Esta estrutura de repetio pode ser substituda por outra que contenha a instruo WHILE,
como segue:
[<rtulo>:] DO WHILE (<condio lgica>)
[<procedimentos>]
END DO [<rtulo>]
Neste caso o DO estar ativo at que a <condio lgica> do WHILE seja falsa.
Vejamos um exemplo do uso de estruturas de repetio. O programa identifica e imprime os primeiros 100 pares no intervalo entre 1 e 1000.
Programa 3.6 Exemplo de estrutura de repetio.
1
2
3
4
5
6
7
8
9
10
11
12
13
PROGRAM numeros_pares
IMPLICIT NONE
INTEGER :: i,j
j=0
DO i=1,1000
WRITE(*,*)"Contador: ", i
IF (MOD(i,2)==0) THEN
WRITE (*,*) "Eh um numero par: ", i
j=j+1
IF (j==100) EXIT
END IF
END DO
END PROGRAM numeros_pares
As estruturas de repetio, assim como as de deciso (IF), tambm podem ser aninhadas, ou seja, podem conter uma dentro da outra. Por exemplo:
ext: DO i=1,20
...
int1: DO
IF (a > b) EXIT int1
...
int2: DO j=200,1,-1
...
END DO int2
...
END DO int1
...
END DO ext
importante que faa os exerccios a seguir. As respostas e comentrios a respeito dos

exerccios esto no site oficial do livro: http://www.orengonline.com/fortran95/.
77
EXERCCIOS
3.1) Criar um programa que entre com um nmero inteiro e informe se ele ou no divisvel
por 5. Dica: aqui ser necessrio testar se o resto de uma diviso por 5 zero ou no. Em Fortran
95 isto feito pela funo MOD(a,b), conforme tabela 1.1, na pgina 31.
3.2) Criar um programa, que entre com um nmero inteiro e informe se ele divisvel por
3 e por 7. Obs.: aqui ser necessrio o uso dos operadores lgicos.
3.3) Criar um programa em Fortran 95, que entre com um nmero inteiro e informe se ele
par ou mpar.
3.4) Segundo uma tabela mdica, o peso ideal est relacionado com a altura e o sexo. Fazer
um programa em Fortran 95 que receba a altura (h) e o sexo de uma pessoa. A seguir
calcule e imprima o seu peso ideal, utilizando as seguintes frmulas: (a) para homens:
(71.7 * h) - 58; (b) para mulheres: (62.1 * h) - 44.7 Dica: no esquea, a altura um nmero real e necessrio saber se homem ou mulher. Ou seja, podemos solicitar a informao
por intermdio da indicao de f ou F, ou m ou M. Revise leitura de caracteres no
Captulo 2.
3.5) Crie trs programas em Fortran 95. O primeiro escrever todos nmeros de 100 at 1.
O segundo escrever os 100 primeiros pares e o ltimo imprimir os mltiplos de 5, no
intervalo de 1 at 500.
3.6) Elabore um programa em Fortran 95, que escreva a soma dos nmeros entre 25 e 200.
Dica: neste caso, a soma realizada da seguinte forma: soma1 = soma1 + 1. No esquea
de informar antes de comear o loop da soma (DO...END DO) o valor inicial de soma1.
3.7) Crie um programa em Fortran 95, que escreva a soma dos nmeros pares entre 25 e 200.
Dica: se baseie no exerccio 3.6.
3.8) Criar um programa em Fortran 95, que escreva o fatorial de um dado nmero. Importante: existe limite (de mquina) para o tamanho do nmero? Dica: no esquea que no
definido fatorial de nmero negativo e que 0!=1.
3.9) Criar um programa que encontre o n-simo termo da srie de Fibonacci. A srie de
Fibonacci dada por: fib(n) = fib(n 1) + fib(n 2) para n > 1. Para n = 0 e n = 1, o
valor por definio fib(0) = 0 e fib(1) = 1.
3.10) Criar dois programas. O primeiro ler 15 nmeros e escrever quantos nmeros maiores que 30 foram digitados. O segundo receber 20 nmeros e escrever a soma dos
positivos e o total de nmeros negativos.
3.11) Criar um programa que entre com um nome e escreva-o tantas vezes quantos forem
seus caracteres.
3.12) Criar um programa que entre com uma palavra e escreva conforme o exemplo a seguir:
Palavra: AMOR. A sada ser AMOR, AMO, AM, A
78
3.13) Criar um programa que entre com dois nmeros e escreva todos os nmeros no intervalo fechado, do menor para o maior.
3.14) Criar um programa para ler o nmero de termos da srie (N ) e escrever o valor de H,
sendo: H = 1 12 + 13 14 + ... + N1 .
3.15) Um restaurante faz uma promoo semanal de descontos para clientes de acordo com
as iniciais do nome da pessoa. Projete um programa, em Fortran 95, que leia o primeiro
nome do cliente, o valor de sua conta e se o nome iniciair com as letras A, D, M ou S,
dar um desconto de 30 %. Para o cliente cujo nome no se inicia por nenhuma dessas
letras, exibir a mensagem Que pena. Nesta semana o desconto no para seu nome,
mas continue nos prestigiando que sua vez chegar.
3.16) Faa um programa que leia um nmero inteiro de 3 algarismos e imprima uma informao se o algarismo da casa das centenas par ou mpar.
3.17) Crie um programa para ler um nmero inteiro de 4 algarismos e imprimir se ou no
mltiplo de quatro o nmero formado pelos algarismos que esto nas casas da unidade
e da centena.
3.18) Desenvolva um programa que leia o ano de nascimento de uma pessoa e o ano atual.
A seguir imprima a idade da pessoa. No se esquea de verificar se o ano de nascimento
um ano vlido.
3.19) Construir um programa em Fortran 95 que calcule a mdia aritmtica de vrios valores
inteiros positivos, lidos externamente. O final da leitura acontecer quando for lido um
valor negativo. Mostrar o resultado ao final.
3.20) Escreva um programa em Fortran 95 que calcule a mdia dos nmeros digitados pelo
usurio, se eles forem pares. Termine a leitura se o usurio digitar 0 (zero). Mostrar o
resultado ao final.
3.21) Desenvolva um programa em Fortran 95 que some os nmeros fornecidos pelo usurio
at que o nmero lido seja igual a zero e mostre a soma.
3.22) Chico tem 1,5 metros e cresce 2 centmetros por ano, enquanto Z tem 1,1 metros e
cresce 3 centmetros por ano. Faa um programa que calcule e mostre quantos anos
sero necessrios para que Z seja maior que Chico.
3.23) Faa um programa em Fortran 95 que leia um nmero n que indicar quantos valores
devem ser lidos a seguir e, para cada nmero lido, mostre uma tabela contendo o valor
lido e o cubo do nmero somado a ele mesmo.
3.24) Elabore um programa em Fortran 90/95 que encontre um nmero real que mais se
aproxima da raiz quadrada de um nmero fornecido pelo usurio. Indique tambm ao
final quantos loops foram necessrios. (Obs.: no basta s calcular a raiz quadrada direta
pela funo SQRT, mas sim fazer um loop com a multiplicao de dois nmeros iguais e que
satisfaa ao teste de preciso entre o valor calculdado e o valor (exato) da raiz.)
CAPITULO
AS VARIVEIS COMPOSTAS:
Vetores e Matrizes (Arranjos)
4.1 Introduo . . . . . . . . . . . . . . . . . .
4.2 Os Vetores . . . . . . . . . . . . . . . . .
4.2.1 Preenchendo com valores os elementos de um vetor . . . . . . . . . . .
4.2.2 A manipulao dos elementos de um
vetor . . . . . . . . . . . . . . . . .
4.3 As Matrizes . . . . . . . . . . . . . . . . .
4.3.1 A declarao de uma matriz . . . . .
4.3.2 Preenchendo com valores os elementos de uma matriz . . . . . . . . . .
4.3.3 A manipulao dos elementos de
uma matriz . . . . . . . . . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . .
75
76
Saudade (09/09/2004 - 11:00)
77
Eternidade: tanto faz

dia aps dia se faz
Saudade: esta faz
o tempo ser sagaz
78
79
80
Gilberto Orengo
1961
80
81
83
4.1
INTRODUO
At o momento escrevemos programas cujas variveis armazenam um nico valor, chamadas de variveis simples. Por exemplo,
INTEGER :: a
REAL :: total
...
a = 34
total = 3.78
Existem casos que precisamos armazenar diferentes valores para uma mesma varivel.
Estas variveis so conhecidas como arrays, em ingls, ou simplesmente de variveis compostas. As variveis compostas mais conhecidas so os vetores e matrizes. Um vetor pode ser
considerado uma matriz sob certas condies, e neste caso chamado de matriz coluna ou
matriz linha. A seguir veremos cada um em detalhes, iniciando pelos vetores.
4.2
80
CAPTULO 4. AS VARIVEIS COMPOSTAS ARRANJOS
OS VETORES
Os vetores so variveis compostas unidimensionais. Por exemplo, seja o vetor R =
que tem seus componentes dados por:
5i 1j + 7k,
R = {5, 1, 7}
em que rx = 5; ry = 1 e rz = 7. De uma forma geral, um vetor A ter componentes
descritos da seguinte maneira:
A = {a1 , a2 , a3 , , an }
O termo varivel composta unidimensional reconhecido pelo o nico ndice necessrio para
descrever a varivel, ou seja, no exemplo acima a varivel A tem um ndice (n) para indicar a posio no conjunto de valores atribudos a ela. Os valores assumido pelo ndice n
determinar a quantidade de elementos do vetor.
Na memria, a varivel R armazenar seus componentes representada esquematicamente como segue, na Figura 4.1.
1
-1
nome
R
5
Joo Maria
Figura 4.1 Representao na memria das variveis R e nome.

Na representao acima foi acrescentado um exemplo de um vetor que armazena caracteres. O vetor nome armazena os caracteres (ou string) Joo e Maria. J a varivel R armazena
valores inteiros. Um vetor s armazenar valores de um mesmo tipo, isto , nunca poderemos armazenar num vetor, por exemplo, valores reais e inteiros ao mesmo tempo. Teremos
que criar uma varivel que armazene os valores reais e outra para os inteiros.
4.2.1
A declarao de um vetor
A declarao de um vetor, ou de uma varivel composta unidimensional, segue a seguinte

estrutura, conhecida como arrays de forma-explcita:
<tipo> [([KIND=]<par_rep>)], [<atrib>] [::] <var>(<forma>)
ou
<tipo> [([KIND=]<par_rep>)], DIMENSION(<forma>),[<atrib>][::] <var>
em que:
<tipo> : um dos tipos de dados estudados anteriormente e podem ser: INTEGER, REAL,
COMPLEX, LOGICAL e CHARACTER, respectivamente representando, inteiros, reais, complexos, lgicos e caracteres.
81
([KIND=]<par_rep>) : em Fortran 95, cada um dos cinco tipos intrnsecos anteriores

possui um valor inteiro no negativo denominado parmetro de representao do tipo de
dado. Este parmetro o valor correspondente em bytes disponibilizados para sua representao, como vimos em detalhes para os inteiros e reais, a partir da pgina 23.
Na normatizao da linguagem Fortran 90/95 ficou estabelecido um padro: qualquer
processador deve suportar pelo menos dois parmetros de representao (o KIND) para
os tipos de dados REAL e COMPLEX e pelo menos um parmetro para os tipos de dados
INTEGER, CHARACTER e LOGICAL.
A tabela B.1, no Apndice B, contm todos os tipos de dados, seus parmetros de representao e intervalos de armazenamento, baseado no compilador G95.
DIMENSION(<forma>) : indica a forma de uma array, em que (<forma>) unidimensional, ou seja, com um nico valor indica que um vetor, cujo valor informa o nmero de
elementos do vetor.
<atrib> :
tros:
so informaes adicionais a respeito do tipo de dado e podem ser, entre ou-
PARAMETER : indica que o dado ser constante ao longo de todo o programa, sem possi-
bilidades de alter-lo,
ALLOCATABLE : usado juntamente com o DIMENSION e indica que o tamanho da array
ser informado ao longo do programa e no no momento da declarao da varivel.

a chamada alocao dinmica de memria e ser estudada no Captulo 5.
Obs.:
Podem ser declarados mais de um atributo para a mesma varivel, os quais sero separados por vrgula.
:: :
os uso dos dois dois pontos opcional, mas ser obrigatrio caso deseja-se inicializar
a varivel no momento da sua declarao.
<var> : so os nomes das variveis que armazenaro os dados, separados por vrgulas. O
nome de uma varivel poder ter at 31 caracteres e iniciar sempre com uma letra do
alfabeto, jamais com um algarismo, que poder ser utilizado a partir da segunda posio,
assim como o underscore (_). No conter caracter especial ( , ( ){ }[ ]! . : @ # $ % & *)
em qualquer posio do nome, bem como letras acentuadas ou cedilhadas.
So exemplos de declarao de vetores
INTEGER :: A(5), R(3)
REAL :: h(10)
CHARACTER(LEN=5) :: nome(2)
ou por:
INTEGER, DIMENSION(5) :: A
INTEGER, DIMENSION(3) :: R
REAL, DIMENSION(10) :: h
CHARACTER(LEN=5), DIMENSION(2) :: nome
82
Na primeira representao, a varivel A armazenar 5 valores inteiros, ou com outras

palavras, o vetor A possui 5 elementos. Desta forma, o vetor h poder armazenar 10 valores
do tipo real. O termo poder est bem colocado, pois a varivel declarada como vetor ter
um limite que armazenar, podendo no ser completado. Por exemplo, no caso da varivel
A se informarmos 4 valores, o vetor passar a ter 4 elementos e no 5. Neste caso, a memria
ser ocupada de forma no otimizada, pois requisitou-se que reservasse um espao para 5
elementos e estamos s ocupando 4. Opostamente, se informarmos 6 elementos no lugar de 5,
estaremos cometendo um erro, pois a varivel ir armazenar somente nos espaos permitidos
na declarao.
Nos nossos exemplos anteriores, na pg. 80 (Figura 4.1), a varivel R armazenar 3 valores (elementos) inteiros. A varivel nome armazenar dois valores, de tamanho igual a 5
caracteres cada. O argumento LEN indica o tamanho de cada varivel do tipo caracter. Se
este argumento for omitido, ser assumido o valor default igual a 1. No exemplo abaixo,
CHARACTER(LEN=1), DIMENSION(3) :: nome1
equivalente a
CHARACTER, DIMENSION(3) :: nome1
e a varivel composta (array) armazenar 3 valores de tamanho igual a 1 cada.
Na segunda representao, inserido o argumento DIMENSION, no qual, entre parnteses, indicamos a quantidade de elementos do vetor, ou seja, a sua dimenso.
BOA PRTICA DE PROGRAMAO
Adotar a ltima representao para a declarao de variveis compostas (com DIMENSION),
pois torna-se mais claro para o programador e para o compilador.
4.2.2
Preenchendo com valores os elementos de um vetor
O procedimento para preencher uma varivel composta diferente da simples, pois temos
que informar todos os elementos de uma varivel com o mesmo nome. Existem diferentes
formas de fazer esta tarefa, veremos algumas.
Preenchendo todos os elementos de uma nica vez
Para preencher uma varivel composta, por exemplo A, de uma nica vez o procedimento :
A =10
ou ainda, na prpria declarao da varivel:
INTEGER, DIMENSION(5) :: A = 10
Assim, todos os elementos da varivel A, do tipo real, sero preenchidos pelo valor igual a
10.
83
O uso de uma estrutura de repetio (loops), e da instruo READ

Este procedimento executado como segue:
DO i=1,5
READ(*,*)A(i)
END DO
Neste caso, usamos a estrutura de repetio DO ... END DO, associado com a instruo
de leitura, via teclado, READ(*,*) para preencher os valores da varivel composta A. O procedimento o seguinte: no loop, para i=1 o primeiro elemento A(1) ser lido e armazenado;
na sequncia para i=2 o segundo elemento A(2) e assim, sucessivamente, at o ltimo elemento A(5) seja lido e armazenado.
O uso de uma estrutura de repetio, em conjunto com uma expresso
x = 0
DO i = 1,5
A(i) = x + i**2
x = x + 3
END DO
Assim, os valores dos elementos da varivel sero: A(1) = 1, A(2) = 7, A(3) = 15, A(4) = 25
e A(5) = 37. A funo utilizada foi x+i2 , em que i o prprio contador, mas no necessrio.
A funo poderia ser simplesmente x + x5 , por exemplo.
4.2.3
A manipulao dos elementos de um vetor
Podemos manipular os elementos como nos exemplos abaixo:

y = A(3)
b = A(1) + A(5)
Nestes casos, tomando os valores atribudos a varivel composta A, os resultados sero y=15
e b=38. As variveis y e b so do tipo simples. Na ltima linha temos a soma de elementos
do vetor.
Podemos multiplicar cada elemento de um vetor por um escalar como segue:
C = 5*A
A varivel C do mesmo tipo da varivel A, ou seja, composta. Este procedimento tambm
pode ser adotado para a diviso.
A soma ou subtrao de vetores:
O Fortran 95 permite a operao em bloco de soma ou subtrao de vetores, desde que
os vetores sejam conformes, isto , tenham a mesma dimenso (forma) ou mesmo nmero de
elementos. Por exemplo:
84
INTEGER, DIMENSION(5) :: A = 10
INTEGER, DIMENSION(5) :: B = 2
INTEGER, DIMENSION(5) :: C
...
C = A + B
O resultado um vetor com os elementos todos iguais a 12, j que todos os vetores tem
dimenso igual a 5.
A multiplicao de vetores:
A multiplicao de vetores possvel desde que os vetores sejam conformes, isto ,
tenham a mesma dimenso. Este procedimento um produto interno (ou produto escalar) e
em Fortran 95 realizado com a instruo DOT_PRODUCT(vetor1,vetor2), como segue:
INTEGER, DIMENSION(5) :: A=10, B=2
INTEGER :: C
C = DOT_PRODUCT(A,B)
que equivalente a:
C = A(1)*B(1) + A(2)*B(2) + ... + A(5)*B(5)
ou a:
C = SUM(A*B)
em que, neste ltimo, foi utilizado a instruo SUM para somar os elementos do produto de
dois vetores. O resultado final simplesmente um nmero, e neste exemplo o resultado
100.
4.3
AS MATRIZES
As matrizes so variveis compostas bidimensionais. Por exemplo, seja a matriz:

2 3
A=
10 6
em que a11 = 2; a12 = 3; a21 = 10 e a22 = 6, so seus componentes. De uma forma geral, a
matriz A22 , ter componentes descritos da seguinte maneira:
A = {a11 , a12 , a21 , a22 }
e neste caso disposta linhas por colunas.
Na memria, a varivel A armazenar seus componentes representada esquematicamente como segue, na Figura 4.2, dispondo linhas por colunas.
A matriz A, armazena valores inteiros, ordenados por linha. Assim, na primeira linha
temos os elementos 2 e 3. Perceba que desta forma, os elementos de uma matriz so armazenados na memria em uma sequncia de linhas. Podemos efetuar o ordenamento por
85

1
A
A(1, 1) A(1, 2) A(2, 1) A(2, 2)
-2
10
Figura 4.2 Representao na memria da varivel composta A.
coluna. A diferena no ordenamento por linha ou coluna est no momento da montagem da

matriz, ou seja, na informao passada para a memria. Isto ser visto logo a seguir.
Uma matriz, assim como um vetor, s armazenar valores de um mesmo tipo, isto ,
nunca poderemos armazenar numa matriz valores reais e inteiros ao mesmo tempo. Teremos
que criar uma varivel que armazene os valores reais e outra para os inteiros.
4.3.1
A declarao de uma matriz
A declarao de uma matriz, ou de uma varivel composta bidimensional, segue a seguinte

estrutura:
1
2
3
INTEGER :: A(2,2)
REAL :: h(4,3)
CHARACTER :: nomes(2,5)
ou por:
1
2
3
INTEGER, DIMENSION(2,2) :: A
REAL, DIMENSION(4,3) :: h
CHARACTER, DIMENSION(2,5) :: nomes
A varivel A ter 2 linhas por 2 colunas, isto , a primeira informao entre parnteses se
refere ao nmero de linhas, enquanto que a segunda se refere ao nmero de colunas. Assim,
a matriz A armazenar 4 valores inteiros. Este resultado vem da multiplicao do nmero de
linhas pelo nmero de colunas, ou seja, 2 2 = 4. A varivel h armazenar 12 valores, em 4
linhas e 3 colunas; e a varivel nomes ter 10 entradas, em 2 linhas e 5 colunas.
4.3.2
Preenchendo com valores os elementos de uma matriz
O procedimento para preencher uma varivel composta semelhante a de um vetor. Assim,

como no caso dos vetores, existem diferentes formas de realizar esta tarefa.
O uso de uma estrutura de repetio
1
2
3
4
5
DO i = 1, 2
DO j = 1, 2
READ(*,*)A(i,j)
END DO
END DO
Neste caso, usamos a estrutura de repetio DO ... END DO, associado com a instruo de leitura READ para preencher os valores da varivel composta A.
86
importante ressaltar que o preenchimento da matriz se fez pelas linhas. Isto , para
cada valor de de i o valor da varivel de controle j, que representa as colunas, varia de 1
at 2 para cada repetio externa. Se quisermos preencher por colunas, basta trocar a linha 1
pela 2. Assim, estaremos fixando o j e variando o i, para cada repetio externa.
O uso de uma estrutura de repetio, em conjunto com uma expresso
Da mesma forma utilizada para os vetores, temos:
1
2
3
4
5
6
7
x = 0
DO i = 1,2
DO j = 1,2
A(i,j) = x + j
x = x + 3
END DO
END DO
Neste caso, os valores da varivel sero: A(1, 1) = 1, A(1, 2) = 5, A(2, 1) = 7 e

A(2, 2) = 11. Novamente aqui foi utilizado o contador interno j na expresso (funo)
matemtica. Esta no necessariamente uma prtica de programao, poderamos trocar
por uma outra expresso.
4.3.3
A manipulao dos elementos de uma matriz
Elemento a elemento:
Podemos manipular os elementos como segue, atribuindo-as a varivies simples. Nos
exemplos abaixo os valores dos elementos foram retirados da matriz anterior A22 :
y = A(2,1)
b = A(1,1) + A(2,2)
Nestes casos, os resultados para as variveis simples so, respectivamente, y = 7 e

b = 12.
A soma ou subtrao de matrizes:
A soma ou subtrao de matrizes possvel desde que as matrizes sejam conformes,
isto , que tenham mesma dimenso. Por exemplo:
1
2
3
4
5
INTEGER, DIMENSION(5,3) :: A = 10
INTEGER, DIMENSION(5,3) :: B = 12
INTEGER, DIMENSION(5,3) :: C
.
.
.
C = A + B
O resultado uma matriz com os elementos todos iguais a 22. A soma realizada elemento
a elemento, conforme apresentado abaixo.
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
53
12
12
+
12
12
12
12
12
12
12
12
12
12
12
12
12
53
10 + 12
10 + 12
=
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
10 + 12
53
22
22
=
22
22
22
22
22
22
22
22
22
22
22
22
22
53
87
Este procedimento pode ser usado para multiplicarmos ou dividirmos elemento a elemento de matrizes conformes.
A multiplicao de matrizes:
A multiplicao de matrizes possvel desde que os matrizes sejam conformes, isto ,
que o nmero de colunas da primeira matriz seja igual ao nmero de linhas da segunda
matriz. Suponha duas matrizes A(x,y) e B(m,n). Assim:
A(x,y) B(m,n) s possvel se e somente se y = m. A matriz resultante ser do tipo x,n.
B(m,n) A(x,y) s possvel se e somente se n = x. A matriz resultante ser do tipo m,y.
Isto , com as matrizes A43 e B35 , a matriz resultante ser C45 . Por exemplo:
1
2
3
INTEGER, DIMENSION(4,3) :: A = 10
INTEGER, DIMENSION(3,5) :: B = 2
INTEGER, DIMENSION(4,5) :: C
Matematicamente produzir:
10
10
10
10
10
10
10
10
10
10
10
10 43
2
2
2
2
2
2
2
2
2
2
2
2
2
=
2
2 35
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60
60 45
A multiplicao em Fortran pode ser realizada por pelo menos maneiras. Especialmente
em Fortran 90/95, podemos utilizar a instruo MATMUL(matriz1,matriz2), como segue:
C = MATMUL(A,B)
que equivalente a:
C(1,1) = A(1,1)*B(1,1) + A(1,2)*B(2,1) + A(1,3)*B(3,1)
.
.
.
.
.
.
C(4,5) = A(4,1)*B(1,5) + A(4,2)*B(2,5) + A(4,3)*B(3,5)
ou a:
DO i = 1,4
DO k = 1,5
C(i,k)=0
DO j = 1,3
C(i,k) = C(i,k) + A(i,j)*B(j,k)
END DO
END DO
END DO
em que, neste ltimo, foi utilizado uma estrutura de repetio DO ... END DO para multiplicar duas matrizes. O ltimo procedimento necessrio nos programas escritos em no
FORTRAN 77. No Fortran 90/95 este procedimento foi incorporado de forma intrnsica. Isto
, quando a instruo MATMUL utilizada a sequncia de loops anteriores executada. Observe, atentamente, que os ndices da matriz resultante do produto so para linhas e colunas,
respectivamente, iguais a i e k e, o ndice j igual ao nmero de colunas da primeira matriz
ou igual ao nmero de linhas da segunda matriz.
88
Em resumo: A multiplicao de matrizes definida somente para duas matrizes que

o nmero de colunas da primeira matriz igual ao nmero de linhas da segunda matriz.
Assim, se uma matriz A uma matriz M N e uma matriz B uma matriz N L, ento o
produto C = A B uma matriz M L cujos elementos so dados pela equao
C(i, k) =
N
X
A(i, j) B(j, k) = A(i, 1) B(1, k) + + A(i, N ) B(N, k)
j=1
com i = 1, , M ; k = 1, , L e j = 1, , N .
IMPORTANTE ............
Digite o cdigo abaixo e execute-o.
PROGRAM testabug
IMPLICIT NONE
REAL, DIMENSION(2,2) :: a=RESHAPE((/2., 3., 4., 5./) ,(/2,2/))
INTEGER :: i,j
DO i=1,2
WRITE(*,*)(a(i,j),j=1,2)
END DO
a(1,3)=6.0; a(2,3)=7.0; a(3,3)=10.0; a(3,1)=8.0; a(3,2)=9.0
WRITE(*,*)""
DO i=1,2
WRITE(*,*)(a(i,j),j=1,2)
END DO
WRITE(*,*)""
DO i=1,3
WRITE(*,*)(a(i,j),j=1,3)
END DO
END PROGRAM testabug
Executou? O resultado inesperado, no!? Pois bem, uma vez definida a dimenso da
array, o compilador Fortran mapeia a memria (para arrays) atravs da seguinte expresso:
P OSIO DO E LEMENTO DA A RRAY NA M EMRIA = (j 1) + (i 1)
(4.1)
onde, o nmero de linhas declarado (no DIMENSION), i e j so as linhas e colunas da array,

i.e., a(i, j). Usando a Eq.(4.1), mostre o que ocorreu[N1] . O compilador Fortran posiciona os
elementos de uma array na memria por coluna, ou seja, primeiro a coluna 1, depois a coluna
2 e assim, sucessivamente.
FALAR SOBRE O TEMPO DE MQUINA MANIPULANDO ARRANJOS POR LINHA
OU POR COLUNA ....
A verificao de aprendizado pela prtica com exerccios e com a soluo de problemas. altamente recomendvel que faa os exerccios a seguir, bem como os disponveis no
[N1] NOTA: este tipo de erro pode ser chamado de estouro de ndice para arranjos ou estouro de rea de armazenamento. Este
problema tambm ocorre no compilador C, e a Eq.(4.1) continua sendo vlida trocando-se i por j e, o agora representa o nmero
de colunas declarado. Este um dos problemas dos programas feitos para o rWindows. Eles no possuem um bom controle de erro
por isso aquela tela Erro de Proteo Geral Argh!!!. Este tipo de erro no ocorre, por exemplo, na linguagem Java.
89
site http://www.orengonline.com/fortran95/. Aps este treinamento estar apto a resolver problemas.

importante lembrar que este livro introdutrio e, portanto, no contm todas as capacidades mais avanadas das instrues Fortran. Para uma abordagem neste nvel aconselhase os livros listados nas referncias biblioigrficas.
90
EXERCCIOS
4.1) Escreva um programa em Fortran 95 que leia 1 vetor de 15 elementos inteiros cada. A
seguir mostre o terceiro elemento do vetor e imprima o resultado da multiplicao do
quinto elemento pelo dcimo elemento.
4.2) Escreva um programa em Fortran 95 que leia 2 vetores de 10 elementos inteiros cada.
Criar um terceiro vetor que seja a unio dos dois primeiros. Mostrar o vetor resultante.
4.3) Escreva um programa em Fortran 95 que leia 2 vetores de 8 elementos inteiros cada e,
a seguir, efetue a multiplicao dos vetores e mostre o resultado.
4.4) Criar um programa em Fortran 90 que leia um conjunto de 30 valores e os coloque em
2 vetores conforme forem pares ou mpares. O tamanho de cada vetor de 5 posies.
Se algum vetor estiver cheio, escrev-lo. Terminada a leitura, escrever o contedo dos
dois vetores. Cada vetor pode ser preenchido tantas vezes quantas forem necessrias.
Obs.: o zero no classificado nem como nmero par e nem como mpar.
4.5) Fazer um programa em Fortran 90 que leia um conjunto de 10 valores inteiros, armazeneos em um vetor e escreva-os ao contrrio da ordem de leitura. A sada dos dados deve
ser num arquivo com o nome saida.txt.
4.6) Criar um programa em Fortran 90 que entre com 4 nomes e imprima uma listagem
contendo todos os nomes. Considere que cada nome poder ter at 10 caracteres. A
sada dos dados deve ser num arquivo com o nome nomes.txt.
4.7) Criar um programa em Fortran 90 que leia 6 nmeros reais e os ordene em ordem
decrescente (isto , do maior para o menor valor). Este dar trabalho difcil. Dica:
monte um conjunto de 5 elementos e pense numa estratgia na ponta do lpis antes de se
aventurar no programa. !!!!
4.8) Repita o exerccio 4.7, mas lendo os 6 valores de entrada de um arquivo de nome dados1.txt. Dica: importante, no esquea de criar o arquivo e digitar nele os 6 valores reais.
4.9) Uma empresa deseja aumentar seus preos em 20%. Fazer um programa em Fortran
90/95 que leia o cdigo e o preo de custo de cada produto e calcule o novo preo;
calcule tambm a mdia dos preos com e sem aumento; e mostre o cdigo e o preo
novo de cada produto e, no final, as mdias. A entrada de dados deve terminar quando
for lido um cdigo de produto nulo.
4.10) Elaborar um programa em Fortran 90/95 que leia um conjunto de 8 valores e os escreva
em um vetor. A seguir, separe os valores que so pares e ao final indique quantos so
pares e mpares.
4.11) Escreva um programa em Fortran 90/95 que leia um conjunto de 9 valores reais e os
escreva em uma matriz 3 3. A seguir, divida cada elemento da diagonal da matriz por
2.0 e escreva o resultado.
CAPITULO
A Alocao Dinmica de Memria

(ALLOCATABLE)
Vimos no primeiro captulo como declarar variveis. Aqui nos deteremos um pouco nas arrays[N1] , ou matrizes. Uma array um grupo de variveis ou constantes, todas do mesmo
tipo, que so referidas por um nico nome. Os valores no grupo ocupam localizaes consecutivas na memria do computador. Um valor individual dentro da array chamado de elemento da array e, sua identificao ocorre pelo nome da array juntamente com um subscrito,
que aponta para sua posio dentro da array. Por exemplo, seja uma array de 3 elementos,
cujo nome hoje, teremos como seus elementos hoje(1), hoje(2) e hoje(3). A sua
declarao ser:
REAL(KIND=8), DIMENSION(3) :: hoje
ou
REAL(KIND=8) :: hoje(3)
Isto , a array hoje tem 3 elementos e cada elemento do tipo real de preciso dupla, conforme o KIND=8. Ou, a array poderia ser de valores inteiros:
INTEGER(KIND=4), DIMENSION(3) :: hoje
Assim, quando queremos nos referir a um elemento da array, fazemos hoje(3), que representa um dado valor numrico. As arrays acima so do tipo unidimensional ou rank-1.
As arrays bidimensionais ou rank-2 so, por exemplo:
REAL(KIND=8), DIMENSION(4,4) :: ontem
E nos referimos a um elemento deste tipo de array da mesma forma que o unidimensional
(s que com 2 subscritos), p.ex., ontem(1,2). Existem arrays de dimenses superiores, caso
seja necessrio. Podemos tambm ter arrays de caracteres, no lugar de nmeros:
[N1] Ser usado array(s) e no matriz(es), por ser de uso corrente no meio computacional, e portanto, mais especfico.
At mesmo para no confundirmos com matrizes da Matemtica.
92
CAPTULO 5. A ALOCAO DINMICA DE MEMRIA (ALLOCATABLE)
CHARACTER(len=20), DIMENSION(50) :: nomes

Isto , cada elemento desta array dever ter at 20 caracteres, e endereado como nomes(1),
nomes(2), at nomes(50).
Mas, o que as arrays acima tm em comum? O tamanho de cada array foi declarado
no incio do programa. Este tipo de declarao de array chamado de alocao esttica de
memria, porque o tamanho de cada array deve ser grande o suficiente para conter o maior
valor do problema que o programa ir resolver. Isto pode trazer srias limitaes. Se declararmos uma array, sem saber ao certo seu futuro tamanho, poderemos estar sobrecarregando a
memria do computador, caso venhamos a usar, por exemplo s 20 ou 30% da memria
alocada para a array. Com isso tornaremos a execuo mais lenta ou at mesmo sem memria
suficiente para executar o programa. No outro extremo est o caso de dimensionarmos a
array abaixo do que ela necessitar de alocao de memria. Desta forma, o programa no
poder resolver problemas maiores. Ento, como o programador resolver este problema?
Se o mesmo possuir o programa fonte[N2] , poder alterar a declarao e recompil-lo. Mas,
isto nem sempre possvel. E, como faremos com os programas proprietrios?
A melhor soluo projetar o programa com alocao dinmica de memria. O tamanho da array ser dinamicamente alocada quando for necessrio e no tamanho exato. Assim,
otimizamos e controlamos melhor o uso da memria e, podemos executar problemas tanto
com arrays grandes, quanto pequenas.
5.1
O ATRIBUTO ALLOCATABLE E AS DECLARAES ALLOCATE E
DEALLOCATE
No Fortran 90/95, uma array alocada dinamicamente declarada com o atributo ALLOCATABLE e alocada no programa atravs da declarao ALLOCATE. Quando no precisamos
mais da array, a desalocamos da memria atravs da declarao DEALLOCATE.
A estrutura de uma declarao tpica de array alocada dinamicamente :
REAL, ALLOCATABLE, DIMENSION(:) :: nomes
REAL, ALLOCATABLE, DIMENSION(:,:) :: ontem
Observe que os dois pontos (:) so usados no lugar das declaraes estticas, pois ainda no
sabemos o tamanho da array. O rank da array declarado, mas no o seu tamanho.
Quando o programa executado, o tamanho da array ser especificado pela declarao
ALLOCATE. A forma desta declarao
ALLOCATE(lista das variveis a serem alocadas, STAT=nome do status)
[N2] Open Source: uma boa prtica abrirmos o cdigo fonte de nossos programas, atravs da licena GPLGeneral
Public License[13]. Eles se tornaro mais eficientes, pois outros programadores podero fazer alteraes e nos avisar
das mesmas.
93
Um exemplo:
ALLOCATE(ontem(100,0:10), STATUS=info)
Este procedimento aloca uma array de 100 11, quando for necessrio. O STATUS=info
opcional. Se estiver presente, ele retornar um inteiro. Ser 0 para sucesso na alocao ou
nmero positivo (valor que depender do compilador) para falha na alocao. uma boa
prtica de programao usar o STATUS, pois caso esteja ausente e a alocao falhar, p.ex., por
falta de memria ou por outro erro qualquer (como nome errado de varivel), a execuo do
programa ser abortada. O seu uso feito atravs de um controle de fluxo, tipo IF. Para o
caso acima, temos:
1
2
3
4
5
6
IF (info == 0) THEN
amanha = ontem*10
ELSE
WRITE(*,*) Erro na Alocacao de Memoria. Verifique !!
STOP
END IF
Uma array alocvel no poder ser utilizada num dado ponto do programa at que
sua memria seja alocada para tal. Qualquer tentativa de usar uma array que no esteja
alocada produzir um erro e com isso sua execuo ser abortada. O Fortran 90/95 inclui a
funo lgica intrnseca ALLOCATED(), para habilitar o programa testar o estado da alocao
de uma dada array, antes de tentar us-la. Por exemplo, as seguintes linhas de um cdigo
computacional testam o estado de alocao da array input_data, antes de tentar realmente
utiliz-la:
1
2
3
4
5
6
7
8
REAL, ALLOCATABLE, DIMENSION(:) :: input_data

......
IF (ALLOCATED(imput_data)) THEN
READ(8,*) input_data
ELSE
WRITE(*,*) AVISO: Array nao Alocada !!
STOP
END IF
Esta funo pode ser til em grandes programas, envolvendo muitos procedimentos de
alocao dinmica de memria.
No final do programa ou mesmo quando no precisamos mais da array, devemos desalocla da memria, com a declarao DEALLOCATE, liberando memria para ser reutilizada. A
sua estrutura
DEALLOCATE(lista das variveis a serem desalocadas, STAT=nome do status)
Um exemplo:
DEALLOCATE(ontem(100,0:10), STATUS=info)
onde o STATUS tem o mesmo significado e uso que tem na declarao ALLOCATE. Aps desalocar a array, os dados que a ela pertenciam no existem mais na memria. Ento, tenha
94
muito cuidado. Devemos sempre desalocar qualquer array, uma vez que tenha terminado o
seu uso. Esta prtica especialmente importante em SUBROUTINE e FUNCTION.
5.2
QUANDO DEVEMOS USAR UMA ARRAY?
Em programao, principalmente em Fortran, se fala muito em arrays, mas talvez nunca
nos perguntamos: quando devemos us-las? Em geral, se muitos ou todos os dados devem
estar na memria ao mesmo tempo para resolver um problema eficientemente, ento o uso
de arrays para armazenar estes dados ser apropriado, para este problema. Por outro lado,
arrays no sero necessrias. O exemplo abaixo (parte de um programa) mostra como nem
sempre preciso usar uma array.
1
2
3
4
5
6
7
8
9
10
11
12
....
DO i = 1,n ! Le valores
WRITE(*,*) Entre com o numero:
READ(*,*) x
WRITE(*,*) O numero eh: ,x
sum_x=sum_x + x ! Acumulando a soma
sum_x2=sum_x2 + x**2
END DO
! Agora calcula a media (x_bar) e o desvio padrao (std_dev)
x_bar = sum_x/real(n)
std_dev = SQRT((real(n)*sum_x2 - sum_x**2)/(real(n)*real(n-1)))
....
Perceba que os valores de x no foram armazenados, para clculo da mdia (x_bar) e

do desvio padro (std_dev). Neste caso os dados foram lidos via teclado (linha 5). Estes
mesmos dados poderiam ser lidos de um arquivo.
Os dois maiores problemas associados com uso de arrays desnecessrias so:
5.3
1.
Arrays desnecessrias desperdiam memria. Arrays desnecessrias podem consumir uma

grande quantidade de memria, gerando com isso um programa maior do que ele necessita ser. Um programa grande requer mais memria para execut-lo, e portanto requer
mais disponibilidade do computador. Em alguns casos, o tamanho extra do programa
pode no ser executado num dado computador.
2.
Arrays desnecessrias restringem a eficincia do programa. Para entender este ponto, vamos
considerar o programa-exemplo acima, que calcula a mdia e o desvio-padro de um
conjunto de dados. Se o programa projetado com 1000 elementos estticos como entrada da array, ento ele somente trabalhar para um conjunto de dados de at 1000
elementos. Se ns encontramos um conjunto de dados maior do que 1000 elementos,
o programa ter que ser recompilado e relinked com um tamanho maior para a array.
Por outro lado, um programa que calcula a mdia e o desvio-padro de um conjunto de
dados, que so lidos de um arquivo, no ter limite para o tamanho do conjunto de
dados.
95
MANIPULAO ENTRE ARRAYS

Rapidamente veremos outra caracterstica do Fortran 90/95, que o fato de podermos
operar com arrays, tal como fazemos com nmeros. Isto , quando operamos a + b = c, se
a = 5 e b = 6, c ser 11. Se as arrays so conformes (mesma forma), este tipo de operao fica
subentendida. Vejamos o caso abaixo: (Digite e execute-o!)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
PROGRAM operacao_array
IMPLICIT NONE
INTEGER :: i
REAL, DIMENSION(4) :: a = (/1., 2., 3., 4./)
REAL, DIMENSION(4) :: b = (/5., 6., 7., 8./)
REAL, DIMENSION(4) :: c, d
DO i = 1,4
c(i) = a(i) + b(i)
END DO
d = a + b
WRITE(*,100)c, c
WRITE(*,100)d, d
100 FORMAT ( , A, = , 5(F6.1,1X))
END PROGRAM operacao_array
Neste exemplo, a array c resulta da soma dos elementos conformes da array a com os
da array b. J a array d obtida usando a nova instruo do Fortran 90/95, que faz implicitamente a descrio anterior.
F Lista de Exerccios 2, s assim, exercitando, saberemos de nossas limitaes!!!!
96
CAPITULO
As Sub-rotinas e Funes
6.1 Introduo . . . . . . . . . . . . . . . .
Procedimentos Externos . . . . . .
Procedimentos Internos . . . . . . .
6.2 As Sub-rotinas SUBROUTINE . . . . .
6.3 As Funes FUNCTION . . . . . . . .
6.4 As Bibliotecas de Sub-rotinas e Funes
6.4.1 A biblioteca LAPACK . . . . . . .
Para reflexo !!
.
.
.
.
.
.
.
.
.
.
.
.
.
.
93
93
94
95
97
99
99
S existem duas coisas infinitas: o universo e a estupidez

humana. E no estou muito seguro da primeira.
Albert Einstein
1879 1955
6.1
INTRODUO
possvel escrever um programa completo em Fortran em um nico programa principal. Mas, se o cdigo complexo ou muito extenso, pode ser que um determinado conjunto
de instrues seja realizado repetidas vezes, em pontos distintos do programa. Neste caso,
melhor quebrar o programa em unidades distintas, chamadas de subprogramas. Os subprogramas so unidades de programa que realizam tarefas especficas. Podem ser chamados
pelo nome a partir do programa principal ou de outros subprogramas e, at mesmo por ele
prprio, conhecida como chamada recursiva.
Cada uma dessas unidades de programa corresponde a um conjunto completo e consistente de tarefas que podem ser escritas, compiladas e testadas individualmente. Posteriormente so includas no programa principal para gerar um arquivo executvel.
Outra importante funo dos subprogramas a possibilidade de depurar erros. Assim,
os programadores podem criar o subprograma como uma unidade de programa, tambm
chamada de procedimento em Fortran. Depois de aprovada, isto , aps compilar, testar e
depurar os erros, o subprograma pode ser agregado ao programa principal. Em Fortran h
dois tipos de subprogramas ou procedimentos que se encaixam nesta categoria: sub-rotinas
e funes. A agregao pode ser realizada por procedimento interno ou externo.
PROCEDIMENTOS EXTERNOS
Os procedimentos externos se localizam externamente ao programa principal, isto , aps o
END PROGRAM ou ainda em um arquivo separado, e neste caso podem ser de outra linguagem. Nestes ltimos, o procedimento externo (sub-rotina ou funo), deve ser compilado
separadamente e aps anexado ao executvel principal, por intermdio de opes de compi-
98
CAPTULO 6. AS SUB-ROTINAS E FUNES
lao do programa principal, que veremos nesta seo. Os procedimentos externos de outra
linguagem muito utilizados so os da linguagem C.
A estrutura geral e localizao , para o caso do procedimento externo pertencer ao
mesmo arquivo do programa principal:
[USE nome_do_use]
[IMPLICIT NONE]
declaraes executveis
[procedimentos ou subprogramas externos]
Um programa principal pode ter quantos procedimentos externos forem necessrios.

Se o procedimento externo no estiver contido no mesmo arquivo (.f90) que est o programa
principal necessrio anex-lo no executvel final. Isto realizado compilando-se da seguinte forma. Sejam dois procedimentos externos localizados, respectivamente, nos arquivos
sub1.f90 e sub2.f90, e o programa fonte principal no prog.f90. Para gerar um executavel, de nome calculo1, que contenha os procedimentos externos anexados ao programa
principal, executamos o seguinte comando:
g95 -o calculo1 prog.f90 sub1.f90 sub2.f90
que compila mltiplos arquivos de cdigo fonte e os anexa para produzir um arquivo executvel chamado calculo1 no linux ou unix, ou calculo1.exe no sistema MS Windows.
PROCEDIMENTOS INTERNOS
fortran
95
O Fortran 95 tambm permite procedimentos internos, os quais se localizam no programa

principal aps a instruo CONTAINS, a qual finaliza os procedimentos executveis do programa principal.
A estrutura geral e localizao de um procedimento interno :
[USE nome_do_use]
[IMPLICIT NONE]
declaraes executveis
CONTAINS
[procedimentos ou subprogramas internos]
=
=
Um programa principal pode ter quantos procedimentos internos forem necessrios.

O Fortran tem dois tipos de procedimentos ou subprogramas: sub-rotinas (SUBROUTINE) e funes (FUNCTION). A diferena fundamental entre esses dois tipos que, as subrotinas so chamadas pela instruo CALL, com o respectivo nome, e podem retornar mltiplos resultados atravs de seus argumentos. J as funes so ativadas pelo seu nome na
expresso e, o seu resultado um nico valor passado diretamente pelo uso da funo, como
99
ocorre por exemplo, com o clculo da funo seno ou cosseno, nas funes intrnsecas. Ambos os procedimentos sero descritos a seguir.
Os benefcios dos subprogramas so principalmente:
1. Testes Independentes. Cada subprograma pode ser codificado e compilado como uma
unidade independente, antes de ser incorporado ao programa principal. Este passo
conhecido como uma unidade de teste.
2. Procedimentos Re-utilizveis. Em muitos casos, diferentes partes de um programa podem usar o mesmo subprograma. Com isto reduz o esforo de programao e tambm
simplifica a depurao dos erros.
3. Isolamento do restante do Programa. As nicas variveis no programa principal que
podem se comunicar (e tambm serem trocadas) pelo procedimento so as que esto declaradas nos argumentos.
3. Cooperativismo. Os subprogramas podem ser desenvolvidos por diferentes programadores e em diferentes partes do mundo, e aps disponibilizados para uso. Um exemplo
o repositrio de subprogramas da biblioteca matemica LAPACK, que ser estudada na
pg. 103.
O uso de subprogramas uma boa prtica de programao em cdigos muito extensos.
6.2
AS SUB-ROTINAS SUBROUTINE
Uma sub-rotina um procedimento Fortran que chamado pela declarao CALL, que
recebe valores de entrada e retorna valores de sada atravs de uma lista de argumentos. A
forma geral de uma sub-rotina :
SUBROUTINE <nome_da_sub-rotina>(<lista_de_argumentos>)
IMPLICIT NONE
<declaraes de variveis locais>
...
...
[RETURN]
END SUBROUTINE <nome_da_sub-rotina>
A declarao SUBROUTINE marca o incio de uma sub-rotina. O nome da sub-rotina
deve seguir os padres do Fortran: deve ter at 31 caracteres e pode ter tanto letras do alfabeto como nmeros, mas o primeiro caracter deve ser - obrigatoriamente - uma letra. A
lista de argumentos contm uma lista de variveis, arrays ou ambas que so passadas para
a sub-rotina quando a mesma ativada. Estas variveis so chamadas argumentos mudos
(dummy arguments), porque a sub-rotina no aloca memria para elas. A alocao ser efetivada quando os argumentos forem passados na chamada da sub-rotina.
Qualquer unidade de programa pode chamar uma sub-rotina, at mesmo outra sub-
100
rotina[N1] . Para usar ou chamar uma sub-rotina usado a declarao CALL, da seguinte
maneira:
CALL <nome_da_sub-rotina>(<lista_de_argumentos>)
em que, a ordem e tipo dos argumentos na lista_de_argumentos devem corresponder a
ordem e tipo dos argumentos mudos declarados na sub-rotina. A sub-rotina finaliza sua execuo quando encontra um RETURN ou um END SUBROUTINE e, retorna ao programa que
a requisitou na linha seguinte ao CALL. Quando a execuo encontra um RETURN, imediatamente o fluxo de execuo desviado para a linha que contm o END SUBROUTINE. Um
exemplo simples ilustra melhor o que uma sub-rotina.
Programa 6.1 Um exemplo de sub-rotina.
1
2
3
4
5
6
7
8
9
10
11
12
13
fortran
95
SUBROUTINE exemplo_sub(lado1, lado2, hipotenusa)

IMPLICIT NONE
! Calcula hippotenusa de um triangulo retangulo
! Declaracao dos parametros de chamada
REAL, INTENT(IN) :: lado1
! Dado de entrada da sub-rotina
REAL, INTENT(IN) :: lado2
! Dado de entrada da sub-rotina
REAL, INTENT(OUT) :: hipotenusa ! Dado de saida da sub-rotina
! Declaracao das variaveis locais (internamente a sub-rotina)
REAL :: temp
temp = lado1**2 + lado2**2
hipotenusa = SQRT(temp)
RETURN
END SUBROUTINE exemplo_sub
Neste exemplo, que calcula a hipotenusa de um tringulo retngulo, trs argumentos

so passados para a sub-rotina. Dois argumentos so de entrada (lado1 e lado2) e um de
sada (hipotenusa). Aqui introduzida uma novidade do Fortran 95: o atributo INTENT,
que especifica o uso pretendido dos argumentos da sub-rotina (e tambm das funes), descritos a seguir:
INTENT(IN): este atributo especifica que o argumento do subprograma seja recebido como
dado de entrada pelo subprograma, quando chamado por uma unidade de programa.
Assim, o argumento no poder ser redefinido ou ficar indefinido durante a execuo do
procedimento (subprograma).
INTENT(OUT): este atributo especifica que o argumento do subprograma um dado de
sada do subprograma, quando chamado por uma unidade de programa. Cada argumento associado dessa forma deve ser definido ou atribuido um valor.
INTENT(INOUT): este atributo especifica que o argumento do subprograma seja utilizado
para ambas possibilidades, isto , como como dado de entrada e dado de sada do subprograma, quando chamado por uma unidade de programa. Cada argumento associado
dessa forma deve ser definido ou atribuido um valor.
A varivel temp definida somente para uso interno, i.e., ela no ser acessada externamente a sub-rotina. Esta caracterstica importante porque poderemos usar nomes iguais
para outros procedimentos, desde que um seja interno a(s) sub-rotina(s) e o outro no corpo
[N1] Uma sub-rotina pode chamar outra sub-rotina, mas no a si mesmo, a menos que seja declarada como recursiva.
Mais informaes sobre sub-rotinas recursivas so obtidas nas referncias [6][10].
101
do programa. Esta sub-rotina usada num programa ou em outra sub-rotina, por intermdio da declarao CALL exemplo_sub(lado1, lado2, hipotenusa), como no exemplo abaixo:
Programa 6.2 Um programa para testar a sub-rotina do Programa 6.1.
1
2
3
4
5
6
7
8
9
10
PROGRAM testa_sub
IMPLICIT NONE
REAL :: s1, s2, hip
WRITE(*,*)Indique um dos lados de um triangulo retangulo:
READ(*,*)s1
WRITE(*,*)Indique o outro lado do triangulo retangulo:
READ(*,*)s2
CALL exemplo_sub(s1, s2, hip)
WRITE(*,*) O valor da hipotenusa do triangulo eh: ,hip
END PROGRAM testa_sub
Outras caractersticas importantes, tal como alocao de memria automtica para arrays, esto descritos detalhadamente nas referncias indicadas anteriormente.
6.3
AS FUNES FUNCTION
Uma funo Fortran um procedimento que ativado em uma expresso que pertence
a um comando de programa. A funo retorna um nico valor numrico, ou lgico, ou
caracter ou uma array. O Fortran tem dois tipos de funes: funes intrnsecas e funes
definidas pelo usurio (funes definida-usurio).
Funes intrnsecas, estudadas no Captulo 1, na pgina 30, so prprias (latentes) da
linguagem Fortran, tais como SIN(X), COS(X), SQRT(X), entre outras. Para saber quais so
as funes intrnsecas consulte o Manual do Usurio.
As funes definida-usurio so funes que o programador cria para executar uma
tarefa especfica. A forma geral de uma funo definida-usurio :
[Tipo] FUNCTION <nome_da_funo>(<lista_de_argumentos>)
<declaraes de variveis locais>
...
...
<nome_da_funo = expresso>
[RETURN]
END FUNCTION <nome_da_funo>
A funo definida-usurio (ou simplesmente funo) deve ser iniciada com a instruo
FUNCTION e finalizada com uma instruo END FUNCTION. O nome da funo deve seguir,
como nas sub-rotinas, os padres do Fortran, isto , deve ter at 31 caracteres e pode ter tanto
letras do alfabeto como nmeros, mas o primeiro caracter deve ser obrigatoriamente uma
letra. A funo ativada pelo seu nome, em uma expresso e, sua execuo comea no topo
da funo e termina quando encontra um RETURN ou END FUNCTION. A instruo RETURN
opcional e raramente utilizada, pois a execuo sempre termina num END FUNCTION. A
102
declarao Tipo opcional se a declarao IMPLICIT NONE estiver presente. Caso contrrio, necessrio declarar o tipo de funo. Estes tipos podem ser REAL, INTEGER, COMPLEX,
CHARACTER ou LOGICAL. Aps ser executada, a funo retorna um valor que ser usado
para continuar a execuo da expresso na qual a funo foi chamada. Um exemplo de funo definida-usurio mostrado abaixo, a qual calcula o valor da funo
f (x) = ax2 + bx + c ,
num ponto x.
Programa 6.3 Um exemplo de funo.
1
2
3
4
5
6
7
8
REAL FUNCTION func(x,a,b,c)

! Objetivo: calcular um polinomio quadratico do tipo
!
a*x**2 + b*x + c
IMPLICIT NONE
REAL, INTENT(IN) :: x, a, b, c
! Dados de entrada da funcao
! Calculo da expressao
func = a*x**2 + b*x + c
END FUNCTION func
Esta funo produz um resultado real. Observe que o atributo INTENT no usado com
a declarao do nome da funo func, porque ela sempre ser usada somente como sada.
Note tambm que, se no fosse declarada como real, a varivel func deveria ser declarada
no corpo da FUNCTION, como de hbito. Um programa que usa esta funo pode ser:
Programa 6.4 Um programa para testar funo definida-usurio do Programa 6.3.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
PROGRAM testa_func
IMPLICIT NONE
! Testa a funcao que calcula f(x) = ax**2 + b*x + c
REAL :: func
REAL :: a, b, c, x
WRITE(*,*) Entre com os coef. quadraticos a, b e c:
WRITE(*,*) Digite o coef. a:
READ(*,*) a
WRITE(*,*) Digite o coef. b:
READ(*,*) b
WRITE(*,*) Digite o coef. c:
READ(*,*) c
WRITE(*,*) Entre com a localizacao na qual quer fazer o calculo:
READ(*,*) x
WRITE(*,100) Calculo em (,x,) = , func(x,a,b,c)
100 FORMAT(A,F10.4,A,F12.4)
END PROGRAM testa_func
Note que a funo func declarada como tipo real tanto na prpria funo, como no
programa principal da qual ativada. Para mais informaes, procure pela literatura indicada nas Referncias Bibliogrficas.
103
6.4
AS BIBLIOTECAS DE SUB-ROTINAS E FUNES
A Netlib um conjunto de cdigos matemticos, artigos e base de dados. O endereo
eletrnico http://www.netlib.org/. O uso das subrotinas e fune prontas, como LAPACK e
BLAS, so timos exemplos.
6.4.1
A biblioteca LAPACK
A biblioteca LAPACK escrita em FORTRAN 77 e fornece rotinas para resolver equaes lineares simultneas, solues de sistemas de equaes lineares por mnimos-quadrados, problemas de autovalores, e problemas de valores singulares. Tambm esto disponibilizadas
solues para fatorizao de matrizes associadas (LU, Cholesky, QR, SVD, Schur, Schur generalizada). Solues com matrizes densas e esparsas tambm esto disponveis, bem como
funcionalidades para tratar com matrizes reais e complexas, tanto em preciso simples como
dupla.
Esta parte do livro est em fase de elaborao e finalizao. Desculpe!!!!!
Programa 6.5 A sub-rotina DGESV da LAPACK.
SUBROUTINE DGESV( N, NRHS, A, LDA, IPIV, B, LDB, INFO )
1
2
3
4
5
6
7
*
*
*
*
*
*
-- LAPACK driver routine (version 3.1) -Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
November 2006
.. Scalar Arguments ..
INTEGER
INFO, LDA, LDB, N, NRHS
..
.. Array Arguments ..
INTEGER
IPIV( * )
DOUBLE PRECISION
A( LDA, * ), B( LDB, * )
..
8
9
10
*
*
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Purpose
=======
DGESV computes the solution to a real system of linear equations
A * X = B,
where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
The LU decomposition with partial pivoting and row interchanges is
used to factor A as
A = P * L * U,
where P is a permutation matrix, L is unit lower triangular, and U is
upper triangular. The factored form of A is then used to solve the
system of equations A * X = B.
Arguments
=========
N
(input) INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
(input) INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
104
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
69
70
71
*
*
72
73
74
75
76
77
*
*
*
*
*
79
80
81
82
83
84
85
86
87
88
89
90
91
93
94
*
*
*
96
98
99
*
*
*
101
102
103
105
LDA
(input) INTEGER
The leading dimension of the array A.
LDA >= max(1,N).
IPIV
(output) INTEGER array, dimension (N)

The pivot indices that define the permutation matrix P;
row i of the matrix was interchanged with row IPIV(i).
(input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)

On entry, the N-by-NRHS matrix of right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
(input) INTEGER
The leading dimension of the array B.
INFO
LDB >= max(1,N).
(output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
> 0: if INFO = i, U(i,i) is exactly zero. The factorization
has been completed, but the factor U is exactly
singular, so the solution could not be computed.
=====================================================================
.. External Subroutines ..
EXTERNAL
DGETRF, DGETRS, XERBLA
..
.. Intrinsic Functions ..
INTRINSIC
MAX
..
.. Executable Statements ..
Test the input parameters.
Compute the LU factorization of A.
Solve the system A*X = B, overwriting B with X.

CALL DGETRS( No transpose, N, NRHS, A, LDA, IPIV, B, LDB,
$
INFO )
END IF
RETURN
100
104
(input/output) DOUBLE PRECISION array, dimension (LDA,N)

On entry, the N-by-N coefficient matrix A.
On exit, the factors L and U from the factorization
A = P*L*U; the unit diagonal elements of L are not stored.
CALL DGETRF( N, N, A, LDA, IPIV, INFO )

IF( INFO.EQ.0 ) THEN
95
97
INFO = 0
IF( N.LT.0 ) THEN
INFO = -1
ELSE IF( NRHS.LT.0 ) THEN
INFO = -2
ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
INFO = -4
ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
INFO = -7
END IF
IF( INFO.NE.0 ) THEN
CALL XERBLA( DGESV , -INFO )
RETURN
END IF
78
92
*
*
End of DGESV
105
106
*
END
107
Programa 61: A sub-rotina DGESV da LAPACK

SUBROUTINE DGESV( N, NRHS, A, LDA, IPIV, B, LDB, INFO )
1
2
3
4
5
6
7
*
*
*
*
*
*
-- LAPACK driver routine (version 3.1) -Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
November 2006
.. Scalar Arguments ..
INTEGER
INFO, LDA, LDB, N, NRHS
..
.. Array Arguments ..
INTEGER
IPIV( * )
DOUBLE PRECISION
A( LDA, * ), B( LDB, * )
..
8
9
10
*
*
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
Purpose
=======
DGESV computes the solution to a real system of linear equations
A * X = B,
where A is an N-by-N matrix and X and B are N-by-NRHS matrices.
The LU decomposition with partial pivoting and row interchanges is
used to factor A as
A = P * L * U,
where P is a permutation matrix, L is unit lower triangular, and U is
upper triangular. The factored form of A is then used to solve the
system of equations A * X = B.
Arguments
=========
N
(input) INTEGER
The number of linear equations, i.e., the order of the
matrix A. N >= 0.
NRHS
(input) INTEGER
The number of right hand sides, i.e., the number of columns
of the matrix B. NRHS >= 0.
(input/output) DOUBLE PRECISION array, dimension (LDA,N)

On entry, the N-by-N coefficient matrix A.
On exit, the factors L and U from the factorization
A = P*L*U; the unit diagonal elements of L are not stored.
LDA
(input) INTEGER
The leading dimension of the array A.
LDA >= max(1,N).
IPIV
(output) INTEGER array, dimension (N)

The pivot indices that define the permutation matrix P;
row i of the matrix was interchanged with row IPIV(i).
(input/output) DOUBLE PRECISION array, dimension (LDB,NRHS)

On entry, the N-by-NRHS matrix of right hand side matrix B.
On exit, if INFO = 0, the N-by-NRHS solution matrix X.
LDB
(input) INTEGER
The leading dimension of the array B.
INFO
LDB >= max(1,N).
(output) INTEGER
= 0: successful exit
< 0: if INFO = -i, the i-th argument had an illegal value
106
Continuao do Programa 61 ...

62
63
64
65
66
67
68
*
*
*
*
*
*
*
69
70
71
*
*
72
73
74
75
76
77
*
*
*
*
*
79
80
81
82
83
84
85
86
87
88
89
90
91
93
94
97
98
101
102
.. External Subroutines ..
EXTERNAL
DGETRF, DGETRS, XERBLA
..
.. Intrinsic Functions ..
INTRINSIC
MAX
..
.. Executable Statements ..
Test the input parameters.
Solve the system A*X = B, overwriting B with X.

CALL DGETRS( No transpose, N, NRHS, A, LDA, IPIV, B, LDB,
$
INFO )
END IF
RETURN
96
99
=====================================================================
*
*
*
95
100
if INFO = i, U(i,i) is exactly zero. The factorization

has been completed, but the factor U is exactly
singular, so the solution could not be computed.
INFO = 0
IF( N.LT.0 ) THEN
INFO = -1
ELSE IF( NRHS.LT.0 ) THEN
INFO = -2
ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
INFO = -4
ELSE IF( LDB.LT.MAX( 1, N ) ) THEN
INFO = -7
END IF
IF( INFO.NE.0 ) THEN
CALL XERBLA( DGESV , -INFO )
RETURN
END IF
78
92
> 0:
*
*
*
End of DGESV
END
CAPITULO
As Funes Intrnsecas
SELECTED_REAL_KIND e
SELECTED_INT_KIND
6.1 Selecionando Preciso de Maneira Independente do Processador . . . . . . . . . . . .
Exerccios . . . . . . . . . . . . . . . . . . . .
Para reflexo !!
50
24
Voc no pode provar uma definio. O que voc pode

fazer, mostrar que ela faz sentido.
Albert Einstein
1879 1955
Vimos que na maioria dos computadores, a varivel real default preciso simples, a
qual usualmente tem 4 Bytes, divididos em duas partes: mantissa e expoente. Para a preciso
dupla, usualmente, dedicado 8 Bytes. Usando estas declaraes ficaremos dependentes da
combinao compilador/processador. Podemos comear a alterar esta dependncia, usando
o parmetro KIND na declarao de variveis. Assim, preciso simples e dupla tem valores
especficos neste parmetro. Vejamos os exemplos:
REAL(KIND=1) :: valor_1
REAL(KIND=4) :: valor_2
REAL(KIND=8), DIMENSION(20) :: matriz_a
REAL(4) :: temp
O tipo de valor real especificado nos parnteses aps o REAL, com ou sem KIND=. Uma varivel declarada com este tipo de parmetro chamado de varivel parametrizada. Se nenhum
tipo especificado, ento o tipo real default usado. Mas afinal, que significa o tipo de parmetro (em KIND)? Infelizmente, no temos como saber. Cada compilador livre para atribuir
um nmero para cada tamanho de varivel. Por exemplo, em alguns compiladores, o valor
real com 32 bits igual a KIND=1 e o valor com 64 bits KIND=2, que o caso da combinao
PC/NAGWare FTN90. Em outros compiladores, como PC/Lahey-Fujitsu Fortran 90/95 e
PC/Microsoft PowerStation 4.0, temos KIND=4 e KIND=8, para respectivamente, 32 bits e 64
bits.
Portanto, para tornar nossos programas portveis, entre compiladores e mquinas diferentes, devemos sempre fornecer o valor correto para o tipo de parmetro. Para isso, pode-
default
=
na
omisso de
declarao.
108
CAPTULO 7. AS FUNES INTRNSECAS SELECTED_REAL_KIND E SELECTED_INT_KIND
mos usar a funo intrnseca KIND, que retorna o nmero que especfica o tipo de parmetro
usado para simples e dupla preciso. Uma vez descoberto estes valores, podemos us-los nas
declaraes das variveis reais. Vejamos como funciona a funo intrnseca KIND, atravs de
um programa:
1
2
3
4
5
6
7
8
PROGRAM kinds
! Proposito: determinar os tipos de parametros de simples e
!
dupla precisao num dado computador e compilador
IMPLICIT NONE
! Escreve na tela os tipos de parmetros
WRITE(*,(" O KIND para Precisao Simples eh ",I2))KIND(0.0)
WRITE(*,(" O KIND para Precisao Dupla
eh ",I2))KIND(0.0D0)
END PROGRAM kinds
Na tabela 7.1 apresentado os resultados da execuo deste programa, em quatro diferentes combinaes de Processador/Compilador.
Tabela 7.1 Valores de KIND para valores reais em alguns compiladores
PC-Pentium/Lahey-Fujitsu Fortran 90/95

PC-Pentium/NAGWare Fortran 90
Cray T90 Supercompuador/CF90
SPARC/CF90
32 bits
KIND
64 bits
128 bits
4
1
N/D
4
8
2
8
8
16
N/D
16
N/D
A partir destes resultados podemos migrar entre estas mquinas e compiladores, simplesmente trocando os parmetros do KIND. Vejamos um exemplo de programa que use este
procedimento, com os dados do PC-Pentium/Lahey-Fujitsu Fortran 90/95:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
PROGRAM uso_do_kind
!
! Proposito: usar o KIND como parametro
!
IMPLICIT NONE
INTEGER, PARAMETER :: single = 4
INTEGER, PARAMETER :: double = 8
REAL(KIND=single) :: valor_1
REAL(KIND=double), DIMENSION(20) :: matriz_1
REAL(single) :: temp
.....
executaveis
.....
END PROGRAM uso_do_kind
Se trocarmos de mquina e/ou compilador, basta trocarmos os valores do single e

double, para os correspondentes tipos para simples e dupla preciso, respectivamente. Mas,
o melhor vem agora !!!!
109
7.1
SELECIONANDO PRECISO DE MANEIRA INDEPENDENTE DO
PROCESSADOR
Como j sabemos, o maior problema encontrado quando portamos um programa Fortran de um computador para outro o fato que os termos preciso simples e preciso dupla no
so precisamente definidos. Os valores com preciso dupla tem, aproximadamente, duas vezes o valor dos valores com preciso simples, mas o nmero de bits associado com cada tipo
de nmero real depender de cada compilador. Tambm j sabemos que em muitos computadores, 32 bits est associado com a preciso simples e 64 bits com a dupla preciso. Num
computador Cray diferente, conforme tabela anterior.
Ento, como podemos escrever programas que possam ser facilmente portveis entre processadores diferentes, com definies de preciso simples e dupla diferentes e assim
mesmo funcionar corretamente? A resposta est num dos avanos da linguagem Fortran.
Agora, possvel especificarmos valores para a mantissa e o expoente, conforme a convenincia e, com isso tambm obtermos maior portabilidade do programa. Isto feito atravs de
uma funo intrnseca que seleciona automaticamente o tipo de valor real para usar quando
se troca de computador. Esta funo chamada SELECTED_REAL_KIND. A forma geral desta
funo
SELECTED_REAL_KIND(p=preciso,r=expoente(ou range))
onde preciso o nmero de dgitos decimais requerido e range o tamanho do expoente requerido da potncia de 10. Os dois argumentos preciso e range so argumentos opcionais;
um deles ou ambos podem ser informados. Vejamos os exemplos abaixo:
kind_number
kind_number
kind_number
kind_number
kind_number
kind_number
=
=
=
=
=
=
SELECTED_REAL_KIND(p=6,r=37)
SELECTED_REAL_KIND(p=12)
SELECTED_REAL_KIND(r=100)
SELECTED_REAL_KIND(13,200)
SELECTED_REAL_KIND(13)
SELECTED_REAL_KIND(p=17)
Num computador com processador PC-Pentium e usando o compilador Lahey-Fujitsu Fortran

90/95, a primeira funo retornar um 4, (para preciso simples) e as outras quatro funes
retornaro um 8 (preciso dupla). A ltima funo retornar 16, mas para o compilador da
Portland (PGHPF), retornar um -1, porque no existe este tipo de dado real no processador
Pentium-PC. Outros, retornaro valores distintos, tente voc mesmo descobrir.
Observe que, dos exemplos, que tanto o p= e r= so opcionais e, p= opcional se somente a preciso desejada.
A funo SELECTED_REAL_KIND deve ser usada com precauo, pois a especificao desejada no seu programa pode aumentar o tamanho do mesmo e com isso sua execuo pode ficar mais lento. Por exemplo, computadores com 32 bits tem entre 6 e 7 dgitos decimais de preciso, para as varveis com preciso simples. Assim, se foi especificado
110
CAPTULO 7. AS FUNES INTRNSECAS SELECTED_REAL_KIND E SELECTED_INT_KIND
SELECTED_REAL_KIND(6), ento nestas mquinas ser preciso simples. Entretanto, se

especificar SELECTED_REAL_KIND(7), ser dupla preciso.
possvel usar outras funes intrnsecas para determinar o tipo (KIND) de uma varivel real e, sua preciso e expoente, num dado computador. A tabela 7.2 descreve estas
funes.
Tabela 7.2 Funes Intrnsecas relacionadas com o KIND
Funo
Descrio
SELECTED_REAL_KIND(p,r)
Retorna o menor tipo de parmetro real com um valor mnimo de p dgitos decimais de preciso e mximo intervalo 10r .
Retorna o menor tipo de parmetro inteiro com mximo intervalo 10r .
Retorna o nmero que especifica o tipo de parmetro de X, onde X uma varivel ou constante de algum tipo intrnseco.
Retorna a preciso decimal de X, onde X um valor
real ou complexo.
Retorna o expoente da potncia de 10 para X, onde
X um valor inteiro, real ou complexo.
SELECTED_INT_KIND(r)
KIND(X)
PRECISION(X)
RANGE(X)
Observe, pela tabela 7.2, que o procedimento de escolha de preciso tambm vlido
para os nmeros inteiros. A funo para isto SELECTED_INT_KIND(r), e o exemplo
abaixo ilustra seu uso:
kind_number = SELECTED_INT_KIND(3)
Usando um processador PC-Pentium e o compilador da Lahey/Fujitsu, a primeira funo
retornar um 2 (para 2 Bytes inteiros), representando um intervalo de representao entre
-32.768 e 32.767. Igualmente, a segunda funo retornar um 4 (4 Bytes), que fornecer um
intervalo entre -2.147.483.648 e 2.147.483.647. A ltima funo retornar um 8 (8 Bytes), com
intervalo entre -9.223.372.036.854.775.808 e 9.223.372.036.854.775.807. Em outros compiladores, este ltimo pode retornar -1, pois poder fugir de sua representatividade.
CAPITULO
Os Procedimentos MODULE
A linguagem Fortran surgiu na dcada de 50, sendo a primeira linguagem de alto nvel a
ser criada. Embora seja a precursora das linguagens, ela foi projetada com os conceitos da
programao estruturada. No que diz respeito modularizao de programas, a linguagem
Fortran oferece facilidades atravs de sub-rotinas (SUBROUTINE) e funes (FUNCTION), o
que torna possvel a implementao de programas modulares e estruturados. No Fortran
90/95, esta modularizao teve um avano significativo atravs das declaraes e procedimentos MODULE, tanto que esta declarao tem status de programa. Como veremos, esta
caracterstica muito importante.
Um dos usos da declarao MODULE substituir as declaraes COMMON, no compartilhamento de dados. Antes de estudarmos esta utilidade, veremos qual a funo do COMMON
nos programas Fortran.
8.1
A DECLARAO COMMON
Programas e subprograma em Fortran podem utilizar variveis que so declaradas de
forma a compartilhar uma mesma rea de memria. Este compartilhamento tem a finalidade
de economizar memria, pois variveis de mdulos (ou subprograma) diferentes ocuparo
uma mesma posio de memria. Isto anos atrs era uma caracterstica muito utilizada, pois
era visvel o problema de memria. Hoje, este problema pode at ser amenizado, mas sempre
que pudermos economizar memria, melhor!! Assim, continuamos sempre otimizando o uso
de memria e os COMMON ainda so usados.
O uso do COMMON, e o seu compartilhamento, torna possvel a transferncia de informaes entre subprogramas, sem (ou de forma complementar) a utilizao da passagem por
parmetros. A rea de memria compartilhada pode ser dividida em blocos, onde cada um
recebe um nome ou rtulo. A forma geral de se declarar variveis com rea compartilhada,
conhecida como COMMON, :
COMMON /r1 /lista de identificadores1 /rN /lista de identificadoresN
onde ri so nomes dos rtulos comuns de variveis, lista de identificadoresi so nomes de
variveis simples ou compostas que no podem ser diferentes. Um exemplo, parcialmente
112
CAPTULO 8. OS PROCEDIMENTOS MODULE
reproduzido de um programa:
PROGRAM uso_common
IMPLICIT NONE
INTEGER :: i,m,n1,n2,ue,us
COMMON /area1/n1,n2,m
.....
CALL mdc
.....
END PROGRAM uso_common
!
! Aqui comecam as sub-rotinas
!
SUBROUTINE mdc
INTEGER :: a,aux1,b,m
COMMON /area1/a,b,m
m = b
aux1 = MOD(a,b)
.....
END SUBROUTINE mdc
.....
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Neste exemplo, os parmetros da sub-rotina foram substitudos pelas variveis da rea

area1 da declarao COMMON.
A utilizao de variveis em COMMON no constitui, no entanto, uma boa norma de
programao. A transferncia de valores entre os subprogramas deve ser feita de preferncia
atravs de parmetros; com isto, os subprogramas se tornaro mais independentes, mais
fceis de serem entendidos e modificados.
Os COMMON devem ser usados com cautela para evitar problemas, pois esto sujeitos
a dois tipos de erros. Melhor no usar mesmo!! Porque? Bem...., analisemos um programa, reproduzido parcialmente, que usa COMMON e cuja alocao de memria se encontra
representada ao lado.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
PROGRAM erro_common
IMPLICIT NONE
REAL :: a, b
REAL, DIMENSION(5) :: c
INTEGER :: i
COMMON / common1 / a, b, c, i
.....
CALL cuidado
.....
END PROGRAM erro_common
!
! Aqui comecam a sub-rotina
!
SUBROUTINE cuidado
REAL :: x
REAL, DIMENSION(5) :: y
INTEGER :: i, j
COMMON / common1 / x, y, i, j
.....
END SUBROUTINE cuidado
Representao da Alocao da Memria no COMMON
Programa
Sub-rotina
(erro_common)
(cuidado)
0000
0001
y(1)
0002
c(1)
y(2)
0003
c(2)
y(3)
0004
c(3)
y(4)
0005
c(4)
y(5)
0006
c(5)
0007
Endereo na
Memria
113
1o tipo de erro: observe que os 5 elementos da array c no programa principal e o seus correspondentes na sub-rotina esto desalinhados. Portanto, c(1), no programa principal, ser
a mesma varivel y(2), na sub-rotina. Se as arrays c e y so supostamente as mesmas, este
desalinhamento causar srios problemas.
2o tipo de erro: o elemento real da array c(5) no programa principal idntico a varivel
inteira i, na sub-rotina. extremamente improvvel (e indesejvel) que a varivel real armazenada em c(5) seja usada como um inteiro na sub-rotina cuidado.
Estes tipos de erros podem ser evitados se usarmos a declarao MODULE, no lugar do
COMMON.
8.2
A DECLARAO MODULE
A declarao MODULE (ou mdulo, simplesmente) pode conter dados, procedimentos,
ou ambos, que podemos compartilhar entre unidades de programas (programa principal,
subprograma e em outros MODULE). Os dados e procedimentos estaro disponveis para uso
na unidade de programa atravs da declarao USE, seguida do nome do mdulo. Ficar
mais claro com um exemplo simples.
8.2.1
Compartilhando Dados usando o MODULE
O mdulo abaixo ser compartilhado com outras duas unidades de programas. Vejamos:
MODULE teste
!
! Declara dados para compartilhar entre duas rotinas
!
IMPLICIT NONE
SAVE
INTEGER, PARAMETER :: num_vals = 5
REAL, DIMENSION(num_vals) :: valores
END MODULE teste
A declarao SAVE garante que todos os dados declarados no mdulo sero preservados quando forem acessados por outros procedimentos. Ele deve sempre includo em qualquer mdulo que declara dados compartilhados. Agora, vejamos como usar o mdulo acima,
atravs do seguinte programa:
PROGRAM testa_module
!
! Ilustra o compartilhamento via MODULE
!
USE teste
IMPLICIT NONE
REAL, PARAMETER :: pi = 3.141592
valores = pi*( /1., 2., 3., 4., 5. /)
CALL sub1
SAVE:
um
dos
avanos do
Fortran
90.
114
CONTAINS
SUBROUTINE sub1
!
! Ilustra o compartilhamento via MODULE
!
USE teste
IMPLICIT NONE
WRITE(*,*) valores
END SUBROUTINE sub1
END PROGRAM testa_module
Os contedos do mdulo teste esto sendo compartilhados entre o programa principal e a sub-rotina sub1. Qualquer outra sub-rotina ou funo dentro do programa tambm
poder ter acesso aos dados, simplesmente incluindo a declarao USE.
Mdulos so especialmente teis para compartilhar grandes volumes de dados entre
unidades de programas.
Exerccio: use o MODULE para evitar o erro descrito no exemplo da pgina 112 (programa
erro_common).
Importante:
A declarao USE sempre a primeira declarao no comentada posicionada logo
abaixo a declarao PROGRAM, SUBROUTINE, ou FUNCTION. Evidentemente, antes da
declarao IMPLICIT NONE.
O mdulo deve ser sempre compilado antes de todas as outras unidades de programa
que a usam. Ela pode estar no mesmo arquivo ou arquivo separado. Se estiver no
mesmo arquivo, deve aparecer antes do programa principal. Muitos compiladores suportam a compilao separada e geram um arquivo .mod (ou similar), que contm
informaes sobre o mdulo, para uso mais tarde com a declarao USE.
8.3
OS PROCEDIMENTOS MODULE
Alm de dados, os mdulos tambm podem conter sub-rotinas e funes, que so os
Procedimentos MODULE ou Mdulos. Estes procedimentos so compilados como uma parte
do mdulo e estaro disponveis para as unidades de programa atravs da declarao USE.
Os procedimentos que so includos dentro dos mdulos devem vir aps a declarao dos
dados do mdulo e precedidos por uma declarao CONTAINS. Esta declarao, tem a funo
de instruir o compilador que as declaraes que a seguem so procedimentos includos no
programa e, portanto, devem ser agregados na compilao.
No exemplo abaixo, a sub-rotina sub1, est contida no interior do mdulo mod_proc1.
MODULE mod_proc1
IMPLICIT NONE
!
! Aqui sao declarados os dados
CONTAINS:
outro
avano
do
Fortran
90
e,
especifica
que um
mdulo
ou um
programa
contenham
procedimentos
internos.
115
!
CONTAINS
SUBROUTINE sub1(a, b, c, x, error)
IMPLICIT NONE
REAL, DIMENSION(3), INTENT(IN) :: a
REAL, INTENT(IN) :: b, c
REAL, INTENT(OUT) :: x
LOGICAL, INTENT(OUT) :: error
......
END SUBROUTINE sub1
END MODULE mod_proc1
A sub-rotina sub1 estar disponvel para uso numa unidade de programa atravs do
USE mod_proc1, posicionado como vimos anteriormente. A sub-rotina ativada com a
declarao padro CALL, por exemplo:
PROGRAM testa_mod_proc1
USE mod_proc1
IMPLICIT NONE
......
CALL sub1(a, b, c, x, error)
......
END PROGRAM testa_mod_proc1
8.3.1
Usando Mdulos para Criar Interfaces Explcitas
Mas porque nos darmos o trabalho de incluir procedimentos (sub-rotinas e funes) num
mdulo? J sabemos que possvel compilar separadamente uma sub-rotina e cham-la
numa outra unidade programa, ento porque passar por etapas extras, i.e., incluir uma subrotina num mdulo, compilar o mdulo, declarar o mdulo atravs da declarao USE, e s
a chamar a sub-rotina?
A resposta que quando um procedimento compilado dentro de um mdulo e o mdulo usado numa chamada de programa, todos os detalhes da interface de procedimentos
esto disponveis para o compilador. Assim, quando o programa que usa a sub-rotina compilado, o compilador pode automaticamente verificar o nmero de argumentos na chamada
do procedimento, o tipo de cada argumento, se cada argumento est ou no numa array, e o
INTENT[N1] de cada argumento. Em resumo, o compilador pode capturar muito dos erros
comuns que um programador pode cometer quando usa os procedimentos.
Um procedimento compilado dentro de um mdulo e acessado pelo USE dito ter uma
Interface Explcita. O compilador Fortran conhece todos os detalhes a respeito de cada argumento no procedimento sempre que o mesmo utilizado, e o compilador verifica a interface
para assegurar que est sendo usado adequadamente.
Ao contrrio, procedimentos que no esto em mdulos so chamados ter uma Interface Implcita. Desta forma, o compilador Fortran no tem informaes a respeito destes
[N1] O
INTENT(xx), que especifica o tipo de uso do argumento mudo, onde o xx pode ser IN, OUT e INOUT. O
atributo INTENT(IN) especifica que o argumento mudo entrada na unidade de programa e no pode ser redefinido no seu interior; j o atributo INTENT(OUT) especifica que o argumento mudo sada da unidade de programa
e o atributo INTENT(INOUT) especifica que o argumento mudo tanto de entrada como de sada na unidade de
programa.
INTENT:
outro
avano
do
Fortran
90. Esta
declarao
especifica
a
inteno
de uso
de um
argumento
mudo
116
procedimentos, quando ele compilado numa unidade programa, que o solicite. Assim, ele
assume que o programador realmente verificou corretamente o nmero, o tipo, a inteno de
uso, etc. dos argumentos. Se esta preocupao no foi tomada, numa seqencia de chamada
errada, o programa ser executado com falha e ser difcil de encontr-la.
Nada melhor que um exemplo para dirimir dvidas. O caso a seguir ilustra os efeitos
da falta de concatenao quando a sub-rotina chamada est includa num mdulo. O mdulo
dado por,
1
2
3
4
5
6
7
8
MODULE erro_interf
CONTAINS
SUBROUTINE bad_argumento (i)
IMPLICIT NONE
INTEGER, INTENT(IN) :: i
WRITE(*,*) I = , i
END SUBROUTINE bad_argumento
END MODULE erro_interf
que ser utilizado pelo programa a seguir:

1
2
3
4
5
6
PROGRAM bad_call
USE erro_interf
IMPLICIT NONE
REAL :: x = 1.
CALL bad_argumento (x)
END PROGRAM bad_call
Quando este programa compilado, o compilador Fortran verificar e capturar o erro

de declarao entre as duas unidades de programa, e nos avisar atravs de uma mensagem.
Neste exemplo, que tem uma interface explcita entre o programa bad_call e a sub-rotina
bad_argumento, um valor real (linha 4, do programa principal) foi passado para a subrotina quando um argumento inteiro (linha 5, do mdulo) era esperado, e o nmero foi mal
interpretado pela sub-rotina. Como foi dito, se este problema no estive numa interface explcita, o compilador Fortran no teria como verificar o erro na chamada do argumento.
Exerccio: no exemplo acima, transforme a interface explcita em implcita, isto , simplesmente elimine o mdulo. Compile e execute! O que ocorrer? Dica: elimine o mdulo, o
CONTAINS e coloque a sub-rotina aps o END PROGRAM e s a compile.
Existem outras maneiras de instruir o compilador Fortran para explicitar a verificao nos
procedimentos por interface, o bloco INTERFACE[6][10], que no ser visto aqui.
8.3.2
A Acessibilidade PUBLIC e PRIVATE
Se no for especificado, todas as variveis dos mdulos estaro disponveis para todas as
unidades de programas, que contenham a declarao USE do referido mdulo. Isto pode nem
sempre ser desejado: o caso se os procedimentos do mdulo tambm contenham variveis
que pertenam s as suas prprias funes. Elas estaro mais a salvo se os usurios do pacote
no interfiram com seus trabalhos internos. Por default todos os nomes num mdulo so
PUBLIC, mas isto pode ser trocado usando a declarao PRIVATE. Vejamos o exemplo:
1
2
3
4
5
6
7
8
117
MODULE change_ac
IMPLICIT NONE
PRIVATE
PUBLIC :: casa_1, hotel_rs
REAL :: casa_1, fazenda_rs
INTEGER :: apto_1, hotel_rs
.....
END MODULE change_ac
Neste caso uma unidade de programa, que use este mdulo, no ter acesso as variveis
fazenda_rs e apto_1. Mas, ter acesso as variveis casa_1 e hotel_rs. Sobre mdulos
existem ainda outras caractersticas interessantes, mas isto que vimos j o suficiente para
mostrar a sua potencialidade.
Assim, chegamos ao final deste minicurso de Introduo ao Fortran 90/95. evidente
que o que foi apresentado pode ser aprofundado, principalmente sobre o ltimo assunto:
mdulos e interfaces. Muitas outras novas instrues escaparam ao minicurso (por motivo
bvio!), tais como as instrues FORALL (especfica para processamento paralelo), WHERE,
TYPE, CASE, POINTER e TARGET, que entre outras, tornaram a linguagem Fortran mais poderosa ainda. A proposta inicial era de apresentar alguns avanos que a linguagem Fortran
sofreu nestes ltimos anos e acredito ter alcanado o objetivo. Agora, quando fores usar a
linguagem Fortran, j sabes que a mesma no morreu, como muitos apregoam. Pelo contrrio, ela constantemente atualizada e est, mais do que nunca, forte no seu principal uso:
como ferramenta do meio cientfico.
Agora, j mais embasado, interessante visitar o site (em ingls)
http://www.ibiblio.org/pub/languages/fortran/ch1-2.html,
que traz um texto, de Craig Burley, comparando as linguagens C[16] e Fortran 90/95. Vale a
pena !!!!
F Lista de Exerccios 3. Ufa!! a ltima.
118
APENDICE
A Tabela ASCII de Caracteres

A ASCII (American Standard Code for Information Interchange) uma tabela de padres de caracteres, reproduzida parcialmente a seguir. Para visualizar a tabela completa ASCII e outras,
acesse o endereo eletrnico: http://www.lookuptables.com/.
Tabela A.1 Tabela ASCII de Caracters
Binrio
Decimal
Caracter ASCII
Binrio
Decimal
Caracter ASCII
0010 0000
0010 0001
0010 0010
0010 0011
0010 0100
0010 0101
0011 0000
0011 0001
0011 0010
0011 0011
0011 0100
0011 0101
0011 0110
0011 0111
0011 1000
0011 1001
32
33
34
35
36
37
48
49
50
51
52
53
54
55
56
57
(espao)
!
"
#
$
%
0
1
2
3
4
5
6
7
8
9
0100 0001
0100 0010
0100 0011
0101 1000
0101 1001
0101 1010
0110 0001
0110 0010
0110 0011
0110 0100
0111 1000
0111 1001
0111 1010
0111 1101
0111 1110
65
66
67
88
89
90
97
98
99
100
120
121
122
125
126
A
B
C
X
Y
Z
a
b
c
d
x
y
z
}
'
Fonte: http://en.wikipedia.org/wiki/ASCII, ou em http://www.lookuptables.com/.
120
APNDICE A. A TABELA ASCII DE CARACTERES
APENDICE
Os tipos de Dados do Fortran 95

Tabela B.1 Os tipos de Dados (intrnsecos) suportados pelo Fortran 95, baseado no compilador G95.
Tipo de varivel
(dado)
Parmetro de
Representao
(em Bytes KIND)
INTEGER
INTEGER
INTEGER
INTEGER
1
2
4
8
Observaes
Intervalo: 127 at 127

Intervalo: 32.767 at 32.767
Intervalo: 2.147.483.647 at 2.147.483.647
Intervalo: 9.223.372.036.854.775.808 at
9.223.372.036.854.775.807
REAL
Intervalo: 1.18 1038 at 3.40 1038
REAL
Intervalo: 2.23 10308 at 1.79 10308
REAL
10
Preciso: 78 dgitos decimais

Preciso: aproximadamente 19 dgitos decimais
COMPLEX
Intervalo: 1.18 1038 at 3.40 1038
COMPLEX
Intervalo: 2.23 10308 at 1.79 10308
COMPLEX
10

Preciso: aproximadamente 19 dgitos decimais
LOGICAL
LOGICAL
LOGICAL
LOGICAL
CHARACTER
1
2
4
8
1
Valores: .TRUE. e .FALSE.

Conjunto de cdigos da ASCII
Preciso: 1 caracter
Obs:
indica o caso default, isto , assume-se o valor na ausncia de indicao.
122
APNDICE B. OS TIPOS DE DADOS INTRNSECOS SUPORTADOS PELO FORTRAN 95
APENDICE
Glossrio
ATRIBUIO (assignment) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
uma instruo na forma varivel = valor numrico ou expresso. designado ou identificado pelo smbolo
de igualdade (=). Por exemplo, z = 4, indica que o valor inteiro 4 atribudo a varivel z. Outro
exemplo: x = y**2 + 2.0*y, cujo valor s ser atribudo a varivel x aps a soluo numrica da
expresso a direita.
DISPOSITIVO (device) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
um meio material (ou equipamento), tal como uma unidade de disco (HD, disquete, CD,...), teclado,
monitor, impressora, ou at mesmo a memria do computador.
INSTRUO (statement) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
uma seqncia de tokens, ou seja, uma seqncia de cdigos internos que substituem uma palavra reservada ou declarao de programa em uma linguagem de alto nvel. P. ex., o WRITE, substitui uma
instruo de mquina para imprimir, por intermdio de um dispositivo, o contedo contido em um
referido endereo de memria.
INSTRUO DE ATRIBUIO (assignment statement) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o mesmo que atribuio.
PROCEDIMENTO (procedure) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
um clculo que pode ser invocado durante a execuo de um programa. E pode ser uma sub-rotina
ou uma funo. Pode ser um procedimento intrnsico (p. ex., COS ou EXP), um procedimento externo,
um procedimento mdulo, um procedimento interno (subprograma que vem aps um CONTAINS), um
procedimento mudo, ou uma funo.
124
APNDICE C. GLOSSRIO
APENDICE
Como Abordar um Problema de

Programao
Este texto foi adaptado, com autorizao do autor, do artigo Como Abordar um Problema de
Programao, de Vincius Jos Fortuna, obtido no endereo:
http://olimpiada.ic.unicamp.br/programacao/programacao/dicas
D.1
ANALISE O PROBLEMA (E PROJETE SEU PROGRAMA) ANTES
DE PROGRAM-LO
Nunca inicie a programar a partir do nada. aconselhvel esquematizar alguns pseudocdigos (algoritmos) explicando o que o programa vai fazer (em um nvel mais elevado) antes
de escrever o programa. A exceo quando se trata de um cdigo que voc j escreveu
diversas vezes, por exemplo, encontrar um elemento em um vetor ou determinar se um
nmero par ou mpar.
Ao escrever um programa importante que se tenha pensado muito nele antes, com o
objetivo de visualiz-lo como um todo. Criando um rascunho prvio do programa, podem
aparecer vrias abordagens do problema e as dificuldades ficam mais fceis de serem superadas. Assim, esquematizar o programa ajuda a fixar exatamente o que se deseja e economizase tempo em frente ao monitor na tentativa de escrever um programa que execute o desejado.
D.2
ESCREVA UM CDIGO LEGVEL
Escrever um cdigo legvel muito importante para facilitar o entendimento de um
programa. At para o prprio criador do cdigo. Em programa claro e auto-explicativo fica
mais difcil se perder e torna muito mais fcil a depurao.
126
APNDICE D. COMO ABORDAR UM PROBLEMA DE PROGRAMAO
D.2.1
Comente seu cdigo enquanto escreve, no depois
Comentrios so ferramentas muito teis para tornar o cdigo mais legvel. interessante
comentar tudo que no seja muito claro. No comente algo que seja bvio, como por exemplo
i = 0
! Atribui o valor 0 a varivel i
Comente algo como:

x = LEN(frase) - LEN(frase)/2 ! x recebe a posicao para frase ficar centralizada
Em programas muito grandes ou complicados, interessante criar um cabealho comentado em cada funo, definindo exatamente o que espera-se que ela faa, quais suas
entradas e quais suas sadas. O pseudo-cdigo rascunhado pode ser muito til para isso.
Agindo assim, no se precisa ler diversas linhas de cdigo para saber o que uma funo faz.
recomendvel que se escreva os comentrios enquanto se escreve o programa, porque
menos provvel que se escreva alguma coisa til ou significativa depois. Escreva enquanto
programa e seus comentrios sero muito mais completos.
D.2.2
Utilize margens e indentao apropriadamente
A cada novo loop, expresses condicionais, definio de funes e blocos de comandos, seu
cdigo deve ser indentado um nvel mais direita (pressione [TAB] ou a barra de espao
algumas vezes). Esteja certo de voltar ao nvel de indentao anterior quando terminar o
bloco.
Linhas em branco tambm so muito teis para aumentar a legibilidade do seu cdigo.
Umas duas linhas entre as definies de funes e procedimentos e uma linha entre a definio de variveis e o cdigo iro separar claramente cada parte, o que torna a identificao
delas mais rpida. Isso torna o cdigo bem mais claro.
D.2.3
Use nomes sugestivos para variveis, funes e procedimentos
O cdigo fica incrivelmente mais difcil de ser depurado quando variveis importantes se
chamam p, t, ma1, qq, e assim por diante. Deve-se sempre utilizar nomes sugestivos para as
variveis, funes e procedimentos. O nome deve dar idia do que a varivel representa ou
o que a funo ou procedimento fazem. Por exemplo, se voc quer armazenar o nmero de
alunos em uma varivel, pode-se usar num_alunos. Se for uma funo que calcula o salrio
mdio, pode-se nome-la calc_SalarioMedio().
D.2.4
Utilize funes e procedimentos curtos e objetivos
Evite sempre funes/procedimentos grandes que englobem todo tipo de processamento.

Separe algoritmos distintos em suas prprias funes/procedimentos. Projete sua grande
funo/procedimento em vrias pequenas, de forma que seu programa fique mais fcil de
ler e entender.
Dessa forma, cada parte do seu programa fica bem definida e torna-se muito mais fcil
escrev-lo, pois pode-se faz-lo passo a passo. Dessa forma, a cada parte que se termina,
127
pode-se verificar se ela est correta. Alm disso a localizao de um problema no programa
tambm fica facilitada, pois ele se restringir a um bloco menor de cdigo.
Concluso:
Lembre-se que a maior parte do tempo que se gasta programando corrigindo e modificando cdigo existente. Relativamente pouco tempo realmente utilizado para adicionar
coisas novas. Isso significa que voc gastar muito tempo lendo o seu cdigo, ento faz sentido gastar algum tempo aprendendo a escrever um cdigo legvel. Cdigo legvel fcil de
escrever, fcil de depurar e fcil de manter. Voc realmente sai ganhando!
D.3
SE ESTIVER CONFUSO NA HORA DA DEPURAO
Se voc estiver confuso ao tentar procurar algum problema no seu programa, tente
explic-lo para voc mesmo. Dessa forma possvel notar inconsistncias ou fugas ao algoritmo planejado.
Caso isso no resolva, pode-se tentar executar o programa no papel. Isso se aplica tanto
a cdigos que voc escreveu e no est mais entendendo como a cdigos pegos de outros.
Funciona da seguinte maneira: Pegue uma folha em branco e liste todas as variveis usadas
no programa. Siga linha por linha do cdigo, escrevendo o valor das variveis enquanto
elas mudam, como se voc fosse o computador. Pode-se usar uma calculadora para ajudar
nas contas. Anote todas as sadas em uma folha parte. Aps algumas poucas iteraes a
estrutura bsica do algoritmo e sua inteno devem ficar claras. Tome cuidado, pois nem
sempre o cdigo funciona do jeito que ns pensamos que funciona.
D.4
GUIA PRTICO PARA RESOLUO DE PROBLEMAS DE PROGRAMAO
1) Entender o problema
Esteja certo de que tenha entendido o problema;
O que a entrada?
O que a sada?
2) Resolver o problema mo
Resolva pequenas instncias do problema mo;
O que acontece?
Pense em casos variados;
Pense em como (qual algoritmo) voc utilizou para resolver o problema.
3) Definir o algoritmo
Defina precisamente o algoritmo a ser utilizado
Rascunhe as etapas do programa
128
APNDICE D. COMO ABORDAR UM PROBLEMA DE PROGRAMAO
4) Programar
Como escrever o algoritmo na linguagem utilizada?
Que estrutura de dado utilizar?1
Divida o programa em partes menores (modularizar);
Escreva um programa de fcil leitura;
Pense nos casos patolgicos.2
4) Depurar
Explique o programa para si mesmo;
Por que funciona?
A leitura de dados est sendo feita corretamente?
Variveis inicializadas?
Verificar casos patolgicos;
Localizar o erro restringindo os blocos de cdigos (cercando o erro)
Comandos e loops aninhados corretamente?
Observaes:
1) Que estrutura utilizar?
Qual a melhor forma de representar as variveis do problema. Variveis simples? Vetores? Matrizes? Registros? Alguns vetores? Vetores de registro? Registros de vetores? So
muitas as estruturas utilizveis. Deve-se escolher uma que seja conveniente e que no venha
trazer complicaes mais adiante.
2) Pense nos casos patolgicos
Os casos patolgicos ocorrem quando a propriedade que seu programa utiliza no vale
para alguns valores. Normalmente so o zero, um, valores iniciais ou finais. Por exemplo,
em uma funo que calcula a potncia de um nmero n pelo expoente e. Para isso pode-se
multiplicar o nmero n e vezes. Nesse caso pode-se ter problemas quando o valor de e for
zero, caso que deve ser tratado especialmente (considerando a resposta padro como 1, por
exemplo). Para ilustrar melhor, imagine o caso em que deseja-se verificar se um vetor est
ordenado em ordem no-decrescente. Para isso basta verificar se v[n]<=v[n+1] para todos
os elementos, exceto o ltimo, pois para ele essa propriedade no tem sentido. Os casos
patolgicos so causa de grande parte dos problemas, especialmente quando se trabalha com
ponteiros.
Referncias www.gamedev.net Skiena, Steven S. "The Algorithm Design Manual", Telos,
1997
APENDICE
O LATEX e este Livro

Com o objetivo didtico e, tambm, de incentivo ao uso do LATEX, sero apresentados algumas
das linhas de programao em LATEX, que foram utilizadas na elaborao deste livro.
Trabalho com LATEX desde 1986, e as distribuies que eu utilizo atualmente so o tetex no Linux e MikTeX no Windows. Ambas funcionam perfeitamente, embora eu prefira a
do Linux, por questo puramente ideolgica. Como referido no Captulo 1, o LATEX distribudo gratuitamente, mas no de cdigo aberto, embora as classes (.cls) e pacotes (.sty)
o sejam. Elas so freeware. Para editar os documentos utilizo no Linux, o kile e no Windows, o WinShell, quem podem ser obtidos gratuitamente, respectivamente, nos endereos
(http://kile.sourceforge.net/) e (http://www.winshell.org). Esta escolha uma questo pessoal, pois
existem outros tantos, e esto listados no endereo http://www.ctan.org.
Para abrigar a maioria dos ambientes, comandos e instrues de formatao, que sero
descritos abaixo foi criado o pacote cfglivrof95.sty, que significa configuraes do livro sobre
Fortran 95. Outros foram adicionados no documento fonte principal. importante ressaltar
que constaro somente as formataes que julgo sejam vlidas para um aprendizado diferenciado sobre LATEX. As formataes simples do tipo, distncia entre linhas, tamanho de papel
e de margens, entre outras, foram omitidas para no tornar enfadonho e longo este captulo
do Apndice, e se encontram em qualquer texto sobre o assunto.
E.1
SOBRE O TEXTO
A fonte adotada no texto foi a palatino, tamanho 10pt, habilitada pelo pacote palatino.sty.
Para aproveitamento do papel disponvel na grfica, o tamanho do papel escolhido foi de 21
25 cm, e deixando uma margem segura para corte foi adotado 20, 7 24, 7 cm, configurado
no LATEX pelo pacote geometry.sty.
Para possibilitar a digitao direta dos caracteres acentuados e cedilhados foram utilizados os pacotes e opes (entre colchetes) [latin1]inputenc.sty e [T1]fontenc.sty, sendo que
este ltimo possibilita usar no comando \hyphenation palavras acentuadas e cedilhadas,
permitindo assim melhor controle sobre a separao silbica.
130
APNDICE E. O LATEX E ESTE LIVRO
OS CAPTULOS
Os ttulos dos captulos foram formatados com o pacote fncychap.sty, com a opo Lenny,
desenvolvido por Ulf A. Lindgren. Para obter a formatao desejada as seguintes linhas, no
pacote,
\ChNameVar{\fontsize{14}{16}\usefont{OT1}{phv}{m}{n}\selectfont}
\ChNumVar{\fontsize{60}{62}\usefont{OT1}{ptm}{m}{n}\selectfont}
\CNV\FmN{\@chapapp}\space\CNoV\thechapter%
foram substitudas pelas linhas
\ChNameVar{\color{branco}\fontsize{12}{14}\usefont{OT1}{phv}{m}{n}
\bfseries\selectfont}
\ChNumVar{\color{preto}\fontsize{60}{62}\sffamily\bfseries\selectfont}
\hspace{-.05cm}\CNV\FmN{\@chapapp}\space\CNoV\thechapter%
E foi introduzida no pacote, antes do \parbox[b]{\textwidth}{, a linha:
{\color{cinza4}\rule{1.5\textwidth}{.69cm}}\vspace{-1.53cm}
para gerar o trao horizontal cinza claro, que transpe a margen direita.
Tambm foram alterados os comandos, estes localizados no prembulo do documento
fonte principal:
\ChTitleVar{\Huge\bfseries\sffamily}
\ChRuleWidth{0pt}
\ChNameUpperCase
\ChTitleUpperCase
AS SEES
Os ttulos das sees dos captulos foram formatados com o pacote titlesec.sty, com as seguintes opes:
\titleformat{\section}[block]{\sffamily\Large\bfseries}
{{\bfseries\color{cinza4}\thesection}}{.5em}
{\\[.1mm]\sffamily\Large\bfseries\MakeUppercase}
% Avana o ttulo para a prxima linha
\titlespacing{\section}{-.8cm}{.50cm}{1pc}
E.2
A DEFINIO DOS TONS DE CINZA
Com o pacote color.sty foi possvel definir os seguintes tons de cinza:
\definecolor{cinza1}{cmyk}{0,0,0,0.1} % fraco +++
\definecolor{cinza15}{cmyk}{0,0,0,0.15} %
131
\definecolor{cinza5}{cmyk}{0,0,0,0.5} % medio
\definecolor{cinza9}{cmyk}{0,0,0,0.9} % forte +++
\definecolor{preto}{cmyk}{0,0,0,1}
\definecolor{branco}{cmyk}{0,0,0,0}
Tambm foram definidos o branco e o preto na base CMYK, no lugar da base RGB. Isto
importante no momento da impresso do livro na grfica. Se definirmos tons de cinza com
RGB, estaremos adotando pigmentos coloridos e a impresso sair mais cara. O uso das
definies de tons de cinza no texto pelo comando \ color{cinza4} ou \ textcolor{cinza4},
como aparecero nas outras definies de comandos a seguir. Um exemplo do uso :
O texto ficar {\color{cinza4} cinza} assim.
= O texto ficar cinza assim.
E.3
A NOTA DE MARGEM
A nota de margem para chamar ateno aos elementos novos do Fortran 90, foi gerada com
o seguinte comando:
\newcommand{\FORTRANN}[1]{%
\textcolor{cinza4}{\bfseries #1}\marginpar{%
\sffamily \textcolor{cinza4}{\tiny fortran}\\[-.25cm]%
\bfseries\Large\xspace\textcolor{cinza4}{90}%
}%
}
E.4
AS NOTAS DE OBSERVAES NO TEXTO
As notas utilizadas ao longo do texto, como por exemplo o da pgina 2, foram geradas com
o seguinte comando:
\newcommand{\NOTA}[2]{
\begin{flushright}
\vspace*{-.4cm}%
\begin{minipage}[t]{0.8\textwidth}
{\small\bfseries\sffamily\color{cinza4} #1}\\[-.2cm]
{\color{cinza4}\rule{\textwidth}{.1mm}}
\\[-.05cm]\color{cinza4}\scriptsize\sffamily #2
fortran
95
132
{\color{cinza4}\hrulefill}
\end{minipage}
\end{flushright}\vspace{.1cm}
}
E.5
OS QUADROS DAS INSTRUES FORTRAN 95
Os quadros que contm as formas das sintaxes das instrues Fortran 95, como o exemplo
abaixo,
foram introduzidas pelos ambientes
\begin{sintaxebox}
\begin{Verbatim}[fontfamily=tt,fontseries=b,commandchars=\\\{
\},numbers=none,xleftmargin=5mm,codes={\catcode$=3\catcode^=1}]
\end{Verbatim}
\end{sintaxebox}
sendo que o ambiente sintaxebox, gerado pelas seguintes linhas:
\newlength\Linewidth
\def\findlength{\setlength\Linewidth\linewidth
\addtolength\Linewidth{-4\fboxrule}
\addtolength\Linewidth{-3\fboxsep}
}
\newenvironment{sintaxebox}{\par\centering\begingroup%
\setlength{\fboxsep}{5pt}\findlength%
\setbox0=\vbox\bgroup\noindent%
\hsize=1.0\Linewidth%
\begin{minipage}{1.0\Linewidth}\small}%
{\end{minipage}\egroup%
\vspace{6pt}%
\noindent\textcolor{cinza4}{\fboxsep2.5pt%
{\fboxsep5pt\colorbox{cinza4}{\normalcolor\box0}}}%
\endgroup\par\addvspace{6pt minus 3pt}\noindent%
\normalcolor\ignorespacesafterend}
\let\Sintaxebox\sintaxebox
\let\endSintaxebox\endsintaxebox
O pacote fancyvrb.sty que habilita o ambiente Verbatim.
133
E.6
OS EXEMPLOS DE PROGRAMAS FORTRAN 95
Os exemplos de programas Fortran 95, como o do primeiro programa,
Programa 12: O primeiro programa
WRITE(*,*) Ola mundo externo ....

END
foram introduzidos da seguinte forma:
\begin{programa}{O primeiro programa}
\fvset{fontsize=\scriptsize,numbers=none,fontfamily=tt,
fontseries=b}
\VerbatimInput[xleftmargin=12.5mm]{ex_primeiro.f90}
\end{programa}
no qual foi utilizado novamente o pacote fancyvrb.sty, com a opo do comando
\VerbatimInput, que anexa um arquivo no texto, neste caso o ex_primeiro.f90.
O ambiente programa foi gerado pelas seguintes linhas:
\newcounter{np} % novo contador
\setcounter{np}{1}
\newenvironment{programa}[1]{\par\centering\begingroup%
\setlength{\fboxsep}{5pt}\findlength%
\setbox0=\vbox\bgroup\noindent%
\hsize=1.0\Linewidth%
\begin{minipage}{1.0\Linewidth}\footnotesize
{\bfseries Programa~\thechapter--\arabic{np}:}~#1}%
{\end{minipage}\egroup%
\vspace{6pt}%
\noindent\textcolor{cinza1}{\fboxsep2.5pt%
{\fboxsep5pt\colorbox{cinza1}{\normalcolor\box0}}}%
\endgroup\par\addvspace{6pt minus 3pt}\noindent%
\normalcolor\ignorespacesafterend\refstepcounter{np}}
\let\Programa\programa
\let\endPrograma\endprograma
Para os exemplos de programas que apresentam continuao na pgina seguinte, alterouse o nome do ambiente para contprog e substitui-se a linha
{\bfseries Programa~\thechapter--\arabic{np}:}~#1}%
pela
{\bfseries Continuao do Programa~\thechapter--\arabic{np}} ...}%
134
E.7
OS MINI-SUMRIOS DOS CAPTULOS
A idia deste item no incio de cada captulo tem dois objetivos. Primeiro, informar ao leitor
o que encontrar no decorrer do mesmo e, segundo, transcrever uma frase de um cientista
conhecido, para possibilitar uma reflexo. O LATEX proporciona o pacote minitoc.sty para
gerar mini-sumrios, mas a opo em cri-los manualmente foi para ter controle sobre todo
o contedo deste item, como por exemplo, filtrar os itens que constaro no mini-sumrio.
O comando \INIZIO{#1}{#2} gera o mini-sumrio.
\newcommand{\INIZIO}[2]{\vspace{-.8cm}
{\color{cinza6}%
\rule{\textwidth}{.3mm}\\[.2cm]\noindent\begin{minipage}[t]{0.5\textwidth}%
\tiny
#1
\vspace{.1cm}\mbox{}
\end{minipage}
\hspace{0.05\textwidth}
\begin{minipage}[t]{0.4\textwidth}
\scriptsize\noindent\sffamily
#2
\vspace{.1cm}\mbox{}
\end{minipage}\\
\rule{\textwidth}{.3mm}
}
}
em que o primeiro argumento (#1) a parte da lista de contedos do referido captulo, copiada e editada do arquivo nome_livro.toc, gerado pelo LATEX. O segundo argumento (#2),
contm a frase para reflexo.
E.8
AS REFERNCIAS BIBLIOGRFICAS
REFERNCIAS BIBLIOGRFICAS
[1] KNUTH, D. E. The TEXbook. Reading, Massachusetts: Addison-Wesley, 1984.

[2] LAMPORT, L. LATEX: A document preparation system. Reading, Massachusetts: AddisonWesley, 1986.
[3] GOOSSENS, M., MITTELBACH, F., SAMARIN, A. The LATEX companion. Reading, Massachusetts: Addison-Wesley, 1994.
[4] KOPKA, H., DALY, P. W. A guide to LATEX 2 : Document preparation for beginners and
advanced users. Harlow, England: Addison-Wesley, 1997.
[5] http://www.miktex.org/. Site com links e distribuio gratuita de pacotes, para Windows, como: LaTeX, WinShel, GhostView, e outros ltimo acesso: 02 de junho de
2001.
[6] CHAPMAN, S. J. Fortran 90/95 for scientists and engineers. Boston, Massachusetts: WCB
McGraw-Hill, 1998.
[7] http://www.lahey.com/. ltimo acesso: 03 de junho de 2001.
[8] http://www.pgroup.com/. ltimo acesso: 03 de junho de 2001.
[9] Lahey Computer Systems, Inc., 865 Tahoe Boulevard P.O. Box 6091 Incline Village,
NV 89450-6091. Lahey/fujitsu fortran 95 express users guide/linux edition, 1999. Revision A.
[10] ELLIS, T., PHILIPS, I. R., LAHEY, T. M. Fortran 90 programming. Harlow, England:
Addison-Wesley, 1998.
[11] REID, J. The new features of fortran 2003. ISO/IEC JTC1/SC22/WG5 N1579, Benson,
Oxon OX10 6LX, UK, v. 1, p. 138, 2003.
[12] DE ALENCAR PRICE, A. M., TOSCANI, S. S. Implementao de linguagens de programao:
compiladores. Number 9 in Livros didticos. Porto Alegre: Editora Sagra Luzzatto,
2000.
[13] http://www.linux.org/. ltimo acesso: 03 de junho de 2001.
136
REFERNCIAS BIBLIOGRFICAS
[14] Cray Research, Inc., Eagan USA. Optimizing application code on cray pvp systems: Trvopt
2.0(a), volume i, 1996.
[15] Cray Research, Inc., 2360 Pilot Knob Road Mendota Heights, MN 55120, USA. Cf90T M
commands and directives reference manual, 1994. SR-3901 1.1.
[16] KERNIGHAN, B. W., RITCHIE, D. M. C, a linguagem de programao: Padro ansi. Rio de
Janeiro: Campus, 1989.

Livrof90 V8-Preliminar1 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Livrof90 V8-Preliminar1 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

livrof90_v8-preliminar1 2014/5/5 1:07 page i #1

Srie Linguagem de Programao Cientfica

livrof90_v8-preliminar1 2014/5/5 1:07 page ii #2

Copyright2007 de Gilberto Orengo

Dados Internacionais de Catalogao na Publicao (CIP)

ndices para catlogo sistemtico:

livrof90_v8-preliminar1 2014/5/5 1:07 page iii #3

CONSIDERAES INICIAIS: Apresentando o Fortran

livrof90_v8-preliminar1 2014/5/5 1:07 page iv #4

1.7.2 A Aritmtica com inteiros e reais . .

TRABALHANDO COM ARQUIVOS ENTRADAS/SADAS (I/O) DE DADOS

AS VARIVEIS COMPOSTAS Arranjos

livrof90_v8-preliminar1 2014/5/5 1:07 page v #5

Fortran 95: curso bsico (Gilberto Orengo)

A ALOCAO DINMICA DE MEMRIA (ALLOCATABLE)

AS FUNES INTRNSECAS SELECTED_REAL_KIND E SELECTED_INT_KIND 107

A A Tabela ASCII de Caracteres

B Os tipos de Dados Intrnsecos suportados pelo Fortran 95

D Como Abordar um Problema de Programao

E O LATEX e este Livro

livrof90_v8-preliminar1 2014/5/5 1:07 page vi #6

Os quadros das Instrues Fortran 95

livrof90_v8-preliminar1 2014/5/5 1:07 page vii #7

Fortran 95: curso bsico (Gilberto Orengo)

livrof90_v8-preliminar1 2014/5/5 1:07 page vii #8

livrof90_v8-preliminar1 2014/5/5 1:07 page viii #9

livrof90_v8-preliminar1 2014/5/5 1:07 page ix #10

livrof90_v8-preliminar1 2014/5/5 1:07 page x #11

livrof90_v8-preliminar1 2014/5/5 1:07 page 1 #12

1.5.2 Dados Reais - REAL . . . . . . . . .

livrof90_v8-preliminar1 2014/5/5 1:07 page 2 #13

CAPTULO 1. CONSIDERAES INICIAIS: Apresentando o Fortran

escritas com o tipo typewriter negrito identificaro elementos referentes ao

escritas com o tipo helvtica negrito identificaro exemplos referentes ao LATEX,

os colchetes sempre indicaro que o elemento Fortran 95 opcional, por exemplo,

em sobrescrito identifica uma nota de rodap, em que x ser o nmero da nota.

notas como esta, em fonte helvtica, permitiro inseres informativas, ou

livrof90_v8-preliminar1 2014/5/5 1:07 page 3 #14

Fortran 95: curso bsico (Gilberto Orengo)

livrof90_v8-preliminar1 2014/5/5 1:07 page 4 #15

CAPTULO 1. CONSIDERAES INICIAIS: Apresentando o Fortran

UM BREVE HISTRICO SOBRE O FORTRAN

arquitetura de computador em pipeline (encadeada); 1. CPUUnidade Central de Processamento que

livrof90_v8-preliminar1 2014/5/5 1:07 page 5 #16

Fortran 95: curso bsico (Gilberto Orengo)

torizao), entre outras.

suporte a programao Orientada a Objetos: herana e extenses, poliformismo, alocao

manipulao otimizada de dados: entre outras, a alocao de componentes; o atributo

suporte para as excees do padro para pontos flutuantes (IEEE 1989);

mais interoperabilidade com a linguagem C: permitindo, por exemplo, acesso a bibliotecas

livrof90_v8-preliminar1 2014/5/5 1:07 page 6 #17

CAPTULO 1. CONSIDERAES INICIAIS: Apresentando o Fortran

integrao com sistemas operacionais: que permitir acessar os argumentos na linha de

ISO/IEC 1539-2:2000. Ttulo: Part 2: Varying length strings. Descreve um conjunto de

ISO/IEC 1539-3:1998. Ttulo: Part 3: Conditional compilation. Descreve um conjunto de

livrof90_v8-preliminar1 2014/5/5 1:07 page 7 #18

Fortran 95: curso bsico (Gilberto Orengo)

101 1012 = (1 22 ) + (0 21 ) + (1 20 ) = 510 ,

livrof90_v8-preliminar1 2014/5/5 1:07 page 8 #19

CAPTULO 1. CONSIDERAES INICIAIS: Apresentando o Fortran

Smbolos comuns ou caracteres especiais:

entre eles operadores aritmticos:

> == >= <= / =

WRITE(,) O angulo ,theta,, em graus, &