Este documento apresenta uma introdução à linguagem Fortran 90/95, descrevendo suas origens, padrões e recursos. É dividido em seções tratando de tópicos como formato de código, tipos de variáveis, expressões, comandos de controle de fluxo e processamento de matrizes.

1. Introdu¸˜o ao Fortran 90/95
ca
Apostila preparada para a disciplina de Modelos Computacionais da F´
ısica I, ministrada para o Curso de Licenciatura em F´
ısica do Departamento de F´
ısica, Instituto de F´
ısica e Matem´tica, Funda¸˜o Universidade
a
ca
Federal de Pelotas, Pelotas - RS.
In´
ıcio: Janeiro de 2005.
Vers˜o: 12 de abril de 2010
a

3. Sum´rio
a
Referˆncias Bibliogr´ficas
e
a
v
1 Introdu¸˜o
ca
1.1 As origens da Linguagem Fortran . . . . . . . . . .
1.2 O padr˜o Fortran 90 . . . . . . . . . . . . . . . . .
a
1.2.1 Recursos novos do Fortran 90 . . . . . . . .
1.2.2 Recursos em obsolescˆncia do Fortran 90 .
e
1.2.3 Recursos removidos do Fortran 90 . . . . .
1.3 Uma revis˜o menor: Fortran 95 . . . . . . . . . . .
a
1.3.1 Recursos novos do Fortran 95 . . . . . . . .
1.3.2 Recursos em obsolescˆncia do Fortran 95 .
e
1.3.3 Recursos removidos do Fortran 95 . . . . .
1.4 O Fortran no S´culo XXI: Fortran 2003 . . . . . .
e
1.4.1 Recursos novos do Fortran 2003 . . . . . . .
1.4.2 Recursos em obsolescˆncia do Fortran 2003
e
1.4.3 Recursos removidos do Fortran 2003 . . . .
1.5 O novo padr˜o: Fortran 2008 . . . . . . . . . . . .
a
1.5.1 Recursos novos do Fortran 2008 . . . . . . .
1.6 Coment´rios sobre a bibliografia . . . . . . . . . .
a
1.7 Observa¸˜es sobre a apostila e agradecimentos . .
co
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
3
3
4
4
4
5
5
5
6
6
6
7
7
7
8
2 Formato do C´digo-Fonte
o
2.1 Formato do programa-fonte . .
2.2 Nomes em Fortran 90/95 . . .
2.3 Entrada e sa´ padr˜es . . . .
ıda
o
2.4 Conjunto de caracteres aceitos
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
. 9
. 11
. 11
. 12
3 Tipos de Vari´veis
a
3.1 Declara¸˜o de tipo de vari´vel . . . . . . . . . .
ca
a
3.2 Vari´veis do tipo INTEGER . . . . . . . . . . . .
a
3.3 Vari´veis do tipo REAL . . . . . . . . . . . . . .
a
3.4 Vari´veis do tipo COMPLEX . . . . . . . . . . . .
a
3.5 Vari´veis do tipo CHARACTER . . . . . . . . . . .
a
3.6 Vari´veis do tipo LOGICAL . . . . . . . . . . . .
a
3.7 O conceito de esp´cie (kind) . . . . . . . . . . .
e
3.7.1 Fortran 77 . . . . . . . . . . . . . . . . .
3.7.2 Fortran 90/95 . . . . . . . . . . . . . . .
3.7.2.1 Compilador Intel® Fortran
3.7.2.2 Compilador gfortran . . . . .
3.7.2.3 Compilador F . . . . . . . . . .
3.7.2.4 Literais de diferentes esp´cies .
e
3.7.3 Fun¸˜es intr´
co
ınsecas associadas ` esp´cie
a
e
3.7.3.1 KIND(X) . . . . . . . . . . . .
3.7.3.2 SELECTED_REAL_KIND(P,R) . .
3.7.3.3 SELECTED_INT_KIND(R) . . . .
3.8 Tipos derivados . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
i
13
13
14
14
15
15
16
17
17
17
17
19
19
21
22
22
22
23
23

4. ii
´
SUMARIO
4 Express˜es e Atribui¸˜es Escalares
o
co
4.1 Regras b´sicas . . . . . . . . . . . . . . . . . .
a
4.2 Express˜es num´ricas escalares . . . . . . . . .
o
e
4.3 Atribui¸˜es num´ricas escalares . . . . . . . . .
co
e
4.4 Operadores relacionais . . . . . . . . . . . . . .
4.5 Express˜es e atribui¸˜es l´gicas escalares . . . .
o
co o
4.6 Express˜es e atribui¸˜es de caracteres escalares
o
co
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
27
27
28
29
30
30
32
5 Comandos e Construtos de Controle de Fluxo
5.1 Comandos obsoletos do Fortran 77 . . . . . . .
5.1.1 R´tulos (statement labels) . . . . . . . .
o
5.1.2 Comando GO TO incondicional . . . . . .
5.1.3 Comando GO TO computado . . . . . . .
5.1.4 Comando IF aritm´tico . . . . . . . . .
e
5.1.5 Comandos ASSIGN e GO TO atribu´ . .
ıdo
5.1.6 La¸os DO rotulados . . . . . . . . . . . .
c
5.2 Comando e construto IF . . . . . . . . . . . . .
5.2.1 Comando IF . . . . . . . . . . . . . . .
5.2.2 Construto IF . . . . . . . . . . . . . . .
5.3 Construto DO . . . . . . . . . . . . . . . . . . .
5.3.1 Construto DO ilimitado . . . . . . . . . .
5.3.2 Instru¸˜o EXIT . . . . . . . . . . . . . .
ca
5.3.3 Instru¸˜o CYCLE . . . . . . . . . . . . .
ca
5.4 Construto CASE . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
35
35
35
36
36
36
36
37
37
38
38
39
41
41
42
42
6 Processamento de Matrizes
6.1 Terminologia e especifica¸˜es de matrizes . . . . .
co
6.2 Express˜es e atribui¸˜es envolvendo matrizes . . .
o
co
6.3 Se¸˜es de matrizes . . . . . . . . . . . . . . . . . .
co
6.3.1 Subscritos simples . . . . . . . . . . . . . .
6.3.2 Tripleto de subscritos . . . . . . . . . . . .
6.3.3 Vetores de subscritos . . . . . . . . . . . . .
6.4 Atribui¸˜es de matrizes e sub-matrizes . . . . . . .
co
6.5 Matrizes de tamanho zero . . . . . . . . . . . . . .
6.6 Construtores de matrizes . . . . . . . . . . . . . . .
6.6.1 A fun¸˜o intr´
ca
ınseca RESHAPE. . . . . . . . .
6.6.2 A ordem dos elementos de matrizes . . . . .
6.7 Rotinas intr´
ınsecas elementais aplic´veis a matrizes
a
6.8 Comando e construto WHERE . . . . . . . . . . . . .
6.8.1 Comando WHERE . . . . . . . . . . . . . . .
6.8.2 Construto WHERE . . . . . . . . . . . . . . .
6.9 Matrizes aloc´veis . . . . . . . . . . . . . . . . . .
a
6.10 Comando e construto FORALL . . . . . . . . . . . .
6.10.1 Comando FORALL . . . . . . . . . . . . . . .
6.10.2 Construto FORALL . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
45
45
49
51
52
52
52
53
53
55
56
56
57
57
57
58
59
62
62
62
7 Rotinas Intr´
ınsecas
7.1 Categorias de rotinas intr´
ınsecas . . . . . . . . . . . . .
7.2 Declara¸˜o e atributo INTRINSIC . . . . . . . . . . . . .
ca
7.3 Fun¸˜es inquisidoras de qualquer tipo . . . . . . . . . .
co
7.4 Fun¸˜es elementais num´ricas . . . . . . . . . . . . . . .
co
e
7.4.1 Fun¸˜es elementais que podem converter . . . . .
co
7.4.2 Fun¸˜es elementais que n˜o convertem . . . . . .
co
a
7.5 Fun¸˜es elementais matem´ticas . . . . . . . . . . . . .
co
a
7.6 Fun¸˜es elementais l´gicas e de caracteres . . . . . . . .
co
o
7.6.1 Convers˜es caractere-inteiro . . . . . . . . . . . .
o
7.6.2 Fun¸˜es de compara¸˜o l´xica . . . . . . . . . . .
co
ca e
7.6.3 Fun¸˜es elementais para manipula¸˜es de strings
co
co
7.6.4 Convers˜o l´gica . . . . . . . . . . . . . . . . . .
a o
7.7 Fun¸˜es n˜o-elementais para manipula¸˜o de strings . .
co
a
ca
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
65
65
65
66
66
66
67
67
68
68
69
69
69
69
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

5. ´
SUMARIO
7.8
7.9
7.10
7.11
7.12
7.13
7.14
7.15
7.16
7.17
iii
7.7.1 Fun¸˜o inquisidora para manipula¸˜o de strings . . . . .
ca
ca
7.7.2 Fun¸˜es transformacionais para manipula¸˜o de strings
co
ca
Fun¸˜es inquisidoras e de manipula¸˜es num´ricas . . . . . . .
co
co
e
7.8.1 Modelos para dados inteiros e reais . . . . . . . . . . . .
7.8.2 Fun¸˜es num´ricas inquisidoras . . . . . . . . . . . . . .
co
e
7.8.3 Fun¸˜es elementais que manipulam quantidades reais . .
co
7.8.4 Fun¸˜es transformacionais para valores de esp´cie (kind)
co
e
Rotinas de manipula¸˜o de bits . . . . . . . . . . . . . . . . . .
ca
7.9.1 Fun¸˜o inquisidora . . . . . . . . . . . . . . . . . . . . .
ca
7.9.2 Fun¸˜es elementais . . . . . . . . . . . . . . . . . . . . .
co
7.9.3 Subrotina elemental . . . . . . . . . . . . . . . . . . . .
Fun¸˜o de transferˆncia . . . . . . . . . . . . . . . . . . . . . .
ca
e
Fun¸˜es de multiplica¸˜o vetorial ou matricial . . . . . . . . . .
co
ca
Fun¸˜es transformacionais que reduzem matrizes . . . . . . . .
co
7.12.1 Caso de argumento unico . . . . . . . . . . . . . . . . .
´
7.12.2 Argumento opcional DIM . . . . . . . . . . . . . . . . . .
7.12.3 Argumento opcional MASK . . . . . . . . . . . . . . . . .
Fun¸˜es inquisidoras de matrizes . . . . . . . . . . . . . . . . .
co
7.13.1 Status de aloca¸˜o . . . . . . . . . . . . . . . . . . . . .
ca
7.13.2 Limites, forma e tamanho . . . . . . . . . . . . . . . . .
Fun¸˜es de constru¸˜o e manipula¸˜o de matrizes . . . . . . . .
co
ca
ca
7.14.1 Fun¸˜o elemental MERGE . . . . . . . . . . . . . . . . . .
ca
7.14.2 Agrupando e desagrupando matrizes . . . . . . . . . . .
7.14.3 Alterando a forma de uma matriz . . . . . . . . . . . .
7.14.4 Fun¸˜o transformacional para duplica¸˜o . . . . . . . .
ca
ca
7.14.5 Fun¸˜es de deslocamento matricial . . . . . . . . . . . .
co
7.14.6 Transposta de uma matriz . . . . . . . . . . . . . . . . .
Fun¸˜es transformacionais para localiza¸˜o geom´trica . . . . .
co
ca
e
Fun¸˜o transformacional para dissocia¸˜o de ponteiro . . . . .
ca
ca
Subrotinas intr´
ınsecas n˜o-elementais . . . . . . . . . . . . . . .
a
7.17.1 Rel´gio de tempo real . . . . . . . . . . . . . . . . . . .
o
7.17.2 Tempo da CPU . . . . . . . . . . . . . . . . . . . . . . .
7.17.3 N´meros aleat´rios . . . . . . . . . . . . . . . . . . . . .
u
o
8 Sub-Programas e M´dulos
o
8.1 Unidades de programa . . . . . . . . . . . . . . . . . . . . . .
8.1.1 Programa principal . . . . . . . . . . . . . . . . . . . .
8.1.2 Rotinas externas . . . . . . . . . . . . . . . . . . . . .
8.1.3 M´dulos . . . . . . . . . . . . . . . . . . . . . . . . . .
o
8.2 Sub-programas . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.1 Fun¸˜es e subrotinas . . . . . . . . . . . . . . . . . . .
co
8.2.2 Rotinas internas . . . . . . . . . . . . . . . . . . . . .
8.2.3 Argumentos de sub-programas . . . . . . . . . . . . .
8.2.4 Comando RETURN . . . . . . . . . . . . . . . . . . . . .
8.2.5 Atributo e declara¸˜o INTENT . . . . . . . . . . . . . .
ca
8.2.6 Rotinas externas e bibliotecas . . . . . . . . . . . . . .
8.2.7 Interfaces impl´
ıcitas e expl´
ıcitas . . . . . . . . . . . . .
8.2.8 Argumentos com palavras-chave . . . . . . . . . . . .
8.2.9 Argumentos opcionais . . . . . . . . . . . . . . . . . .
8.2.10 Tipos derivados como argumentos de rotinas . . . . .
8.2.11 Matrizes como argumentos de rotinas . . . . . . . . .
8.2.11.1 Matrizes como argumentos em Fortran 77 . .
8.2.11.2 Matrizes como argumentos em Fortran 90/95
8.2.12 sub-programas como argumentos de rotinas . . . . . .
8.2.13 Fun¸˜es de valor matricial . . . . . . . . . . . . . . . .
co
8.2.14 Recursividade e rotinas recursivas . . . . . . . . . . .
8.2.15 Atributo e declara¸˜o SAVE . . . . . . . . . . . . . . .
ca
8.2.16 Fun¸˜es de efeito lateral e rotinas puras . . . . . . . .
co
8.2.17 Rotinas elementais . . . . . . . . . . . . . . . . . . . .
Autor: Rudi Gaelzer – IFM/UFPel
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
70
70
70
70
71
71
72
72
72
73
73
73
74
74
74
74
75
75
75
75
75
75
76
76
76
76
76
77
77
77
78
78
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
79
79
79
81
81
81
81
83
83
84
84
86
86
88
91
92
92
92
94
97
98
101
103
104
106
Impresso: 12 de abril de 2010

6. ´
SUMARIO
iv
8.3
8.4
M´dulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
8.3.1 Dados globais . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3.2 Rotinas de m´dulos . . . . . . . . . . . . . . . . . . . . . . . .
o
8.3.3 Atributos e declara¸˜es PUBLIC e PRIVATE . . . . . . . . . . . .
co
8.3.4 Interfaces e rotinas gen´ricas . . . . . . . . . . . . . . . . . . .
e
8.3.5 Estendendo rotinas intr´
ınsecas via blocos de interface gen´ricos
e
ˆ
Ambito (Scope) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ˆ
8.4.1 Ambito dos r´tulos . . . . . . . . . . . . . . . . . . . . . . . . .
o
ˆ
8.4.2 Ambito dos nomes . . . . . . . . . . . . . . . . . . . . . . . . .
9 Comandos de Entrada/Sa´ de Dados
ıda
9.1 Comandos de Entrada/Sa´
ıda: introdu¸˜o r´pida
ca a
9.2 Declara¸˜o NAMELIST . . . . . . . . . . . . . . . .
ca
9.3 Unidades l´gicas . . . . . . . . . . . . . . . . . .
o
9.4 Comando OPEN . . . . . . . . . . . . . . . . . . .
9.5 Comando READ . . . . . . . . . . . . . . . . . . .
9.6 Comandos PRINT e WRITE . . . . . . . . . . . . .
9.7 Comando FORMAT e especificador FMT= . . . . . .
9.8 Descritores de edi¸˜o . . . . . . . . . . . . . . . .
ca
9.8.1 Contadores de repeti¸˜o . . . . . . . . . .
ca
9.8.2 Descritores de edi¸˜o de dados . . . . . .
ca
9.8.3 Descritores de controle de edi¸˜o . . . . .
ca
9.8.4 Descritores de edi¸˜o de strings . . . . . .
ca
9.9 Comando CLOSE . . . . . . . . . . . . . . . . . .
9.10 Comando INQUIRE . . . . . . . . . . . . . . . . .
9.11 Outros comandos de posicionamento . . . . . . .
9.11.1 Comando BACKSPACE . . . . . . . . . . . .
9.11.2 Comando REWIND . . . . . . . . . . . . . .
9.11.3 Comando ENDFILE . . . . . . . . . . . . .
Autor: Rudi Gaelzer – IFM/UFPel
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
107
108
111
113
114
117
118
118
118
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
121
121
125
129
129
132
133
134
135
135
136
139
144
146
146
148
149
149
149
Impresso: 12 de abril de 2010

7. Referˆncias Bibliogr´ficas
e
a
[1] Intel® Fortran Compiler for Linux. http://www.intel.com/software/products/compilers/flin/docs/manuals.htm.
Acesso em: 01 jun. 2005.
[2] CHAPMAN, STEPHEN J. Fortran 95/2003 for Scientists and Engineers. McGraw-Hill, 2007, xxvi +
976 pp., 3rd. Edi¸˜o.
ca
[3] MARSHALL, A. C. Fortran 90 Course Notes. http://www.liv.ac.uk/HPC/HTMLFrontPageF90.html,
1996. Acesso em: 01 jun. 2005.
[4] METCALF, MICHAEL, REID, JOHN. Fortran 90/95 Explained. New York : Oxford University Press,
1996, 345 + xv pp.
[5] PAGE, CLIVE G. Professional Programer’s Guide to Fortran77.
prof77.pdf, Leicester, 2001. Acesso em: 01 jun. 2005.
http://www.star.le.ac.uk/ cgp/-
[6] RAMSDEN,
S.,
LIN,
F.,
PETTIPHER,
M.
A.,
NOLAND,
OKE, J. M.
Fortran 90. A Conversion Course for Fortran
http://www.hpctec.mcc.ac.uk/hpctec/courses/Fortran90/F90course.html, 1995.
jun. 2005.
G.
S.,
BRO77 Programmers.
Acesso em: 01
[7] REID,
JOHN.
The
New
Features
of
Fortran
2003.
Publicado
http://www.fortranplus.co.uk/resources/john reid new 2003.pdf, 2004. Acesso em: 03 Jun. 2006.
v
em:

8. vi
Autor: Rudi Gaelzer – IFM/UFPel
ˆ
´
REFERENCIAS BIBLIOGRAFICAS
Impresso: 12 de abril de 2010

9. Cap´
ıtulo 1
Introdu¸˜o
ca
”I don’t know what the technical characteristics of the standard language for scientific and
engineering computation in the year 2000 will be... but I know it will be called Fortran.”
John Backus
Esta apostila destina-se ao aprendizado da Linguagem de Programa¸˜o Fortran 95.
ca
1.1
As origens da Linguagem Fortran
Programa¸˜o no per´
ca
ıodo inicial do uso de computadores para a solu¸˜o de problemas em f´
ca
ısica, qu´
ımica, engenharia, matem´tica e outras ´reas da ciˆncia era um processo complexo e tedioso ao extremo.
a
a
e
Programadores necessitavam de um conhecimento detalhado das instru¸˜es, registradores, endere¸os de meco
c
m´ria e outros constituintes da Unidade Central de Processamento (CPU1 ) do computador para o qual
o
eles escreviam o c´digo. O C´digo-Fonte era escrito em um nota¸˜o num´rica denominada c´digo octal.
o
o
ca
e
o
Com o tempo, c´digos mnemˆnicos foram introduzidos, uma forma de programa¸˜o conhecida como c´digo
o
o
ca
o
num´rico ou c´digo Assembler. Estes c´digos eram traduzidos em instru¸˜es para a CPU por programas
e
o
o
co
conhecidos como Assemblers. Durante os anos 50 ficou claro que esta forma de programa¸˜o era de todo
ca
inconveniente, no m´
ınimo, devido ao tempo necess´rio para se escrever e testar um programa, embora esta
a
forma de programa¸˜o possibilitasse um uso otimizado dos recursos da CPU.
ca
Estas dificuldades motivaram que um time de programadores da IBM, liderados por John Backus, desenvolvessem uma das primeiras chamadas linguagem de alto-n´
ıvel, denominada FORTRAN (significando
FORmula TRANslation). Seu objetivo era produzir uma linguagem que fosse simples de ser entendida e
usada, mas que gerasse um c´digo num´rico quase t˜o eficiente quanto a linguagem Assembler. Desde o
o
e
a
in´
ıcio, o Fortran era t˜o simples de ser usado que era poss´ programar f´rmulas matem´ticas quase como
a
ıvel
o
a
se estas fossem escritas de forma simb´lica. Isto permitiu que programas fossem escritos mais rapidamente
o
que antes, com somente uma pequena perda de eficiˆncia no processamento, uma vez que todo cuidado era
e
dedicado na constru¸˜o do compilador, isto ´, no programa que se encarrega de traduzir o c´digo-fonte em
ca
e
o
Fortran para c´digo Assembler ou octal.
o
Mas o Fortran foi um passo revolucion´rio tamb´m porque o programadores foram aliviados da tarefa
a
e
tediosa de usar Assembler, assim concentrando-se mais na solu¸˜o do problema em quest˜o. Mais imporca
a
tante ainda, computadores se tornaram acess´
ıveis a qualquer cientista ou engenheiro disposto a devotar um
pequeno esfor¸o na aquisi¸˜o de um conhecimento b´sico em Fortran; a tarefa da programa¸˜o n˜o estava
c
ca
a
ca a
mais restrita a um corpus pequeno de programadores especialistas.
O Fortran disseminou-se rapidamente, principalmente nas ´reas da f´
a
ısica, engenharia e matem´tica,
a
uma vez que satisfazia uma necessidade premente dos cientistas. Inevitavelmente, dialetos da linguagem
foram desenvolvidos, os quais levaram a problemas quando havia necessidade de se trocar programas entre
diferentes computadores. O dialeto de Fortran otimizado para processadores fabricados pela IBM, por
exemplo, geralmente gerava erro quando se tentava rodar o mesmo programa em um processador Burroughs,
ou em outro qualquer. Assim, em 1966, ap´s quatro anos de trabalho, a Associa¸˜o Americana de Padr˜es
o
ca
o
(American Standards Association), posteriormente Instituto Americano Nacional de Padr˜es (American
o
National Standards Institute, ou ANSI) originou o primeiro padr˜o para uma linguagem de programa¸˜o,
a
ca
agora conhecido como Fortran 66. Essencialmente, era uma subconjunto comum de v´rios dialetos, de
a
tal forma que cada dialeto poderia ser reconhecido como uma extens˜o do padr˜o. Aqueles usu´rios que
a
a
a
desejavam escrever programas port´veis deveriam evitar as extens˜es e restringir-se ao padr˜o.
a
o
a
1 Do
inglˆs: Central Processing Unit.
e
1

10. 2
1.2. O padr˜o Fortran 90
a
O Fortran trouxe consigo v´rios outros avan¸os, al´m de sua facilidade de aprendizagem combinada com
a
c
e
um enfoque em execu¸˜o eficiente de c´digo. Era, por exemplo, uma linguagem que permanecia pr´xima
ca
o
o
(e explorava) o hardware dispon´
ıvel, ao inv´s de ser um conjunto de conceitos abstratos. Ela tamb´m
e
e
introduziu, atrav´s das declara¸˜es COMMON e EQUIVALENCE, a possibilidade dos programadores controlarem
e
co
a aloca¸˜o da armazenagem de dados de uma forma simples, um recurso que era necess´rio nos prim´rdios da
ca
a
o
computa¸˜o, quando havia pouco espa¸o de mem´ria, mesmo que estas declara¸˜es sejam agora consideradas
ca
c
o
co
potencialmente perigosas e o seu uso desencorajado. Finalmente, o c´digo fonte permitia espa¸os em branco
o
c
na sua sintaxe, liberando o programador da tarefa de escrever c´digo em colunas rigidamente definidas e
o
permitindo que o corpo do programa fosse escrito da forma desejada e visualmente mais atrativa.
A prolifera¸ao de dialetos permaneceu um problema mesmo ap´s a publica¸˜o do padr˜o Fortran 66. A
c˜
o
ca
a
primeira dificuldade foi que muitos compiladores n˜o aderiram ao padr˜o. A segunda foi a implementa¸˜o,
a
a
ca
em diversos compiladores, de recursos que eram essenciais para programas de grande escala, mas que eram
ignorados pelo padr˜o. Diferentes compiladores implementavam estes recursos de formas distintas.
a
Esta situa¸˜o, combinada com a existˆncia de falhas evidentes na linguagem, tais como a falta de consca
e
tru¸˜es estruturadas de programa¸˜o, resultaram na introdu¸˜o de um grande n´mero de pr´-processadores.
co
ca
ca
u
e
Estes eram programas que eram capazes de ler o c´digo fonte de algum dialeto bem definido de Fortran e
o
gerar um segundo arquivo com o texto no padr˜o, o qual ent˜o era apresentado ao compilador nesta forma.
a
a
Este recurso provia uma maneira de estender o Fortran, ao mesmo tempo retendo a sua portabilidade. O
problema era que embora os programas gerados com o uso de um pr´-processador fossem port´veis, podendo
e
a
ser compilados em diferentes computadores, o c´digo gerado era muitas vezes de uma dificuldade proibitiva
o
para a leitura direta.
Estas dificuldades foram parcialmente removidas pela publica¸˜o de um novo padr˜o, em 1978, conhecido
ca
a
como Fortran 77. Ele inclu´ diversos novos recursos que eram baseados em extens˜es comerciais ou pr´ıa
o
e
processadores e era, portanto, n˜o um subconjunto comum de dialetos existentes, mas sim um novo dialeto
a
por si s´. O per´
o
ıodo de transi¸˜o entre o Fortran 66 e o Fortran 77 foi muito mais longo que deveria,
ca
devido aos atrasos na elabora¸˜o de novas vers˜es dos compiladores e os dois padr˜es coexistiram durante
ca
o
o
um intervalo de tempo consider´vel, que se estendeu at´ meados da d´cada de 80. Eventualmente, os
a
e
e
fabricantes de compiladores passaram a liber´-los somente com o novo padr˜o, o que n˜o impediu o uso de
a
a
a
programas escritos em Fortran 66, uma vez que o Fortran 77 permitia este c´digo antigo por compatibilidade.
o
Contudo, diversas extens˜es n˜o foram mais permitidas, uma vez que o padr˜o n˜o as incluiu na sua sintaxe.
o
a
a a
1.2
O padr˜o Fortran 90
a
Ap´s trinta anos de existˆncia, Fortran n˜o mais era a unica linguagem de programa¸˜o dispon´ para
o
e
a
´
ca
ıvel
os programadores. Ao longo do tempo, novas linguagens foram desenvolvidas e, onde elas se mostraram
mais adequadas para um tipo particular de aplica¸˜o, foram adotadas em seu lugar. A superioridade do
ca
Fortran sempre esteve na ´rea de aplica¸˜es num´ricas, cient´
a
co
e
ıficas, t´cnicas e de engenharia. A comunidade
e
de usu´rios do Fortran realizou um investimento gigantesco em c´digos, com muitos programas em uso
a
o
freq¨ente, alguns com centenas de milhares ou milh˜es de linhas de c´digo. Isto n˜o significava, contudo,
u
o
o
a
que a comunidade estivesse completamente satisfeita com a linguagem. V´rios programadores passaram a
a
migrar seus c´digos para linguagens tais como Pascal, C e C++. Para levar a cabo mais uma moderniza¸˜o
o
ca
da linguagem, o comitˆ t´cnico X3J3, aprovado pela ANSI, trabalhando como o corpo de desenvolvimento
e e
do comitˆ da ISO (International Standards Organization, Organiza¸˜o Internacional de Padr˜es) ISO/IEC
e
ca
o
JTC1/SC22/WG5 (doravante conhecido como WG5), preparou um novo padr˜o, inicialmente conhecido
a
como Fortran 8x, e agora como Fortran 90.
Quais eram as justificativas para continuar com o processo de revis˜o do padr˜o da linguagem Fortran?
a
a
Al´m de padronizar extens˜es comerciais, havia a necessidade de moderniza¸˜o, em resposta aos desenvole
o
ca
vimentos nos conceitos de linguagens de programa¸˜o que eram explorados em outras linguagens tais como
ca
APL, Algol, Pascal, Ada, C e C++. Com base nestas, o X3J3 podia usar os ´bvios benef´
o
ıcios de conceitos
tais como ocultamento de dados. Na mesma linha, havia a necessidade de fornecer uma alternativa ` peria
gosa associa¸˜o de armazenagem de dados, de abolir a rigidez agora desnecess´ria do formato fixo de fonte,
ca
a
bem como de aumentar a seguran¸a na programa¸˜o. Para proteger o investimento em Fortran 77, todo o
c
ca
padr˜o anterior foi mantido como um subconjunto do Fortran 90.
a
Contudo, de forma distinta dos padr˜es pr´vios, os quais resultaram quase inteiramente de um esfor¸o
o
e
c
de padronizar pr´ticas existentes, o Fortran 90 ´ muito mais um desenvolvimento da linguagem, na qual s˜o
a
e
a
introduzidos recursos que s˜o novos em Fortran, mas baseados em experiˆncias em outras linguagens. Os
a
e
recursos novos mais significativos s˜o a habilidade de manipular matrizes usando uma nota¸˜o concisa mais
a
ca
poderosa e a habilidade de definir e manipular tipos de dados definidos pelo programador. O primeiro destes
recursos leva a uma simplifica¸˜o na escrita de muitos problemas matem´ticos e tamb´m torna o Fortran
ca
a
e
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

11. Cap´
ıtulo 1. Introdu¸˜o
ca
3
uma linguagem mais eficiente em supercomputadores. O segundo possibilita aos programadores a express˜o
a
de seus problemas em termos de tipos de dados que reproduzem exatamente os conceitos utilizados nas sua
elabora¸˜es.
co
1.2.1
Recursos novos do Fortran 90
Um resumo dos novos recursos ´ dado a seguir:
e
ˆ O Fortran 90 possui uma maneira para rotular alguns recursos antigos como em obsolescˆncia (isto ´,
e
e
tornando-se obsoletos).
ˆ Opera¸˜es de matrizes.
co
ˆ Ponteiros.
ˆ Recursos avan¸ados para computa¸˜o num´rica usando um conjunto de fun¸˜es inquisidoras num´ricas.
c
ca
e
co
e
ˆ Parametriza¸˜o dos tipos intr´
ca
ınsecos, permitindo o suporte a inteiros curtos, conjuntos de caracteres
muito grandes, mais de duas precis˜es para vari´veis reais e complexas e vari´veis l´gicas agrupadas.
o
a
a
o
ˆ Tipos de dados derivados, definidos pelo programador, compostos por estruturas de dados arbitr´rias
a
e de opera¸˜es sobre estas estruturas.
co
ˆ Facilidades na defini¸˜o de coletˆneas denominadas m´dulos, uteis para defini¸˜es globais de dados e
ca
a
o
´
co
para bibliotecas de subprogramas.
ˆ Exigˆncia que o compilador detecte o uso de constru¸˜es que n˜o se conformam com a linguagem ou
e
co
a
que estejam em obsolescˆncia.
e
ˆ Um novo formato de fonte, adequado para usar em um terminal.
ˆ Novas estruturas de controle, tais como SELECT CASE e uma nova forma para os la¸os DO.
c
ˆ A habilidade de escrever subprogramas internos e subprogramas recursivos e de chamar subprogramas
com argumentos opcionais.
ˆ Aloca¸ao dinˆmica de dados (matrizes autom´ticas, matrizes aloc´veis e ponteiros).
c˜
a
a
a
ˆ Melhoramentos nos recursos de entrada/sa´ de dados.
ıda
ˆ V´rios novos subprogramas intr´
a
ınsecos.
Todos juntos, estes novos recursos contidos em Fortran 90 ir˜o assegurar que o padr˜o continue a ser bem
a
a
sucedido e usado por um longo tempo. O Fortran 77 continua sendo suportado como um subconjunto
durante um per´
ıodo de adapta¸˜o.
ca
Os procedimentos de trabalho adotados pelo comitˆ X3J3 estabelecem um per´
e
ıodo de aviso pr´vio antes
e
que qualquer recurso existente seja removido da linguagem. Isto implica, na pr´tica, um ciclo de revis˜o, que
a
a
para o Fortran ´ de cerca de cinco anos. A necessidade de remo¸˜o de alguns recursos ´ evidente; se a unica
e
ca
e
´
a¸˜o adotada pelo X3J3 fosse de adicionar novos recursos, a linguagem se tornaria grotescamente ampla,
ca
com muitos ´
ıtens redundantes e sobrepostos. A solu¸˜o finalmente adotada pelo comitˆ foi de publicar como
ca
e
uma apˆndice ao padr˜o um conjunto de duas listas mostrando quais os ´
e
a
ıtens que foram removidos e quais
s˜o os candidatos para uma eventual remo¸˜o.
a
ca
A primeira lista cont´m os recursos removidos (deleted features). A segunda lista cont´m os recursos
e
e
em obsolescˆncia (obsolescent features), os quais s˜o considerados obsoletos e redundantes, sendo assim
e
a
candidatos ` remo¸˜o na pr´xima revis˜o da linguagem.
a
ca
o
a
1.2.2
Recursos em obsolescˆncia do Fortran 90
e
Os recursos em obsolescˆncia do Fortran 90 s˜o:
e
a
ˆ IF aritm´tico;
e
ˆ desvio para uma declara¸˜o END IF a partir de um ponto fora de seu bloco;
ca
ˆ vari´veis reais e de dupla precis˜o nas express˜es de controle de um comando DO;
a
a
o
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

12. 4
1.3. Uma revis˜o menor: Fortran 95
a
ˆ finaliza¸˜o compartilhada de blocos DO, bem como finaliza¸˜o por uma declara¸˜o ou comando distintos
ca
ca
ca
de um CONTINUE ou de um END DO;
ˆ declara¸˜o ASSIGN e comando GO TO atribu´
ca
ıdo;
ˆ RETURN alternativo;
ˆ comando PAUSE;
ˆ especificadores FORMAT atribu´
ıdos;
ˆ descritor de edi¸˜o H.
ca
1.2.3
Recursos removidos do Fortran 90
Uma vez que Fortran 90 cont´m o Fortran 77 como subconjunto, esta lista permaneceu vazia para o
e
Fortran 90.
1.3
Uma revis˜o menor: Fortran 95
a
Seguindo a publica¸˜o do padr˜o Fortran 90 em 1991, dois significativos desenvolvimentos posteriores
ca
a
referentes ` linguagem Fortran ocorreram. O primeiro foi a continuidade na opera¸˜o dos dois comitˆs de
a
ca
e
regulamenta¸˜o do padr˜o da linguagem: o X3J3 e o WG5; o segundo desenvolvimento foi a cria¸˜o do
ca
a
ca
F´rum Fortran de Alta Performance (High Performance Fortran Forum, ou HPFF).
o
Logo no inicio de suas delibera¸˜es, os comitˆs concordaram na estrat´gia de definir uma revis˜o menor
co
e
e
a
no Fortran 90 para meados da d´cada de 90, seguida por uma revis˜o de maior escala para o in´ dos anos
e
a
ıcio
2000. Esta revis˜o menor passou a ser denominada Fortran 95.
a
O HPFF teve como objetivo a defini¸˜o de um conjunto de extens˜es ao Fortran tais que permitissem a
ca
o
constru¸˜o de c´digos port´veis quando se fizesse uso de computadores paralelos para a solu¸˜o de problemas
ca
o
a
ca
envolvendo grandes conjuntos de dados que podem ser representados por matrizes regulares. Esta vers˜o
a
do Fortran ficou conhecida como o Fortran de Alta Performance (High Performance Fortran, ou HPF),
tendo como linguagem de base o Fortran 90, n˜o o Fortran 77. A vers˜o final do HPF consiste em um
a
a
conjunto de instru¸˜es que cont´m o Fortran 90 como subconjunto. As principais extens˜es est˜o na forma
co
e
o
a
de diretivas, que s˜o vistas pelo Fortran 90 como coment´rios, mas que s˜o reconhecidas por um compilador
a
a
a
HPF. Contudo, tornou-se necess´ria tamb´m a inclus˜o de elementos adicionais na sintaxe, uma vez que
a
e
a
nem todos os recursos desejados puderam ser acomodados simplesmente na forma de diretivas.
`
A medida que os comitˆs X3J3 e WG5 trabalhavam, este comunicavam-se regularmente com o HPFF.
e
Era evidente que, para evitar o surgimento de dialetos divergentes de Fortran, havia a necessidade de
incorporar a sintaxe nova desenvolvida pelo HPFF no novo padr˜o da linguagem. De fato, os recursos do
a
HPF constituem as novidades mais importantes do Fortran 95. As outras mudan¸as consistem em corre¸˜es,
c
co
clarifica¸˜es e interpreta¸˜es do novo padr˜o. Estas se tornaram prementes quando os novos compiladores
co
co
a
de Fortran 90 foram lan¸ados no mercado e utilizados; notou-se uma s´rie de erros e detalhes obscuros que
c
e
demandavam repara¸˜es. Todas estas mudan¸as foram inclu´
co
c
ıdas no novo padr˜o Fortran 95, que teve a sua
a
vers˜o inicial lan¸ada no pr´prio ano de 1995.2
a
c
o
O Fortran 95 ´ compat´
e
ıvel com o Fortran 90, exceto por uma pequena altera¸˜o na fun¸˜o intr´
ca
ca
ınseca
SIGN (se¸˜o 7.4.2) e a elimina¸˜o de recursos t´
ca
ca
ıpicos do Fortran 77, declarados em obsolescˆncia no Fortran
e
90. Os detalhes do Fortran 95 foram finalizados em novembro de 1995 e o novo padr˜o ISO foi finalmente
a
publicado em outubro de 1996.
1.3.1
Recursos novos do Fortran 95
Os novos recursos do Fortran 95 est˜o discutidos ao longo desta apostila. Em rela¸˜o ao Fortran 90,
a
ca
foram introduzidos os seguintes recursos:
ˆ Concordˆncia aprimorada com o padr˜o de aritm´tica de ponto flutuante bin´ria da IEEE (IEEE 754
a
a
e
a
ou IEC 559-1989).
ˆ Rotinas (procedures) puras (se¸˜o 8.2.16).
ca
ˆ Rotinas (procedures) elementais (se¸˜o 8.2.17).
ca
2 Fortran
95, Commitee Draft, May 1995. ACM Fortran Forum, v. 12, n. 2, June 1995.
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

13. Cap´
ıtulo 1. Introdu¸˜o
ca
5
ˆ Dealoca¸˜o autom´tica de matrizes aloc´veis (p´gina 61).
ca
a
a
a
ˆ Comando e construto FORALL (se¸˜o 6.10).
ca
ˆ Extens˜es do construto WHERE (p´gina 58).
o
a
ˆ Fun¸˜es especificadoras.
co
ˆ Inicializa¸˜o de ponteiro e a fun¸˜o NULL (se¸˜o 7.16).
ca
ca
ca
ˆ Inicializa¸˜o de componentes de tipo derivado (p´gina 25).
ca
a
ˆ Fun¸˜es elementares CEILING, FLOOR e SIGN (se¸˜es 7.4.1 e 7.4.2).
co
co
ˆ Fun¸˜es transformacionais (7.15).
co
ˆ Subrotina intr´
ınseca CPU_TIME (se¸˜o 7.17.2).
ca
ˆ Coment´rio na entrada de uma lista NAMELIST (p´gina 128).
a
a
ˆ Descritores de edi¸˜o com largura de campo m´
ca
ınimo.
ˆ Especifica¸˜o gen´rica na cl´usula END INTERFACE.
ca
e
a
1.3.2
Recursos em obsolescˆncia do Fortran 95
e
Os recursos abaixo entraram na lista em obsolescˆncia do Fortran 95 e, portanto, pouco ou nada foram
e
comentados ao longo desta Apostila.
ˆ Formato fixo de fonte.
ˆ Comando GO TO computado.
ˆ Declara¸˜o de vari´vel de caractere na forma CHARACTER*.
ca
a
ˆ Declara¸˜es DATA entre comandos execut´veis.
co
a
ˆ Fun¸˜es definidas em uma linha (statement functions).
co
ˆ Extens˜o assumida de caracteres quando estas s˜o resultados de fun¸˜es.
a
a
co
1.3.3
Recursos removidos do Fortran 95
Cinco recursos foram removidos do padr˜o da linguagem Fortran 95 e, portanto, n˜o ser˜o mais aceitos
a
a
a
por compiladores que respeitam o padr˜o Fortran 95.
a
ˆ ´
Indices de la¸os DO do tipo real (qualquer esp´cie).
c
e
ˆ Declara¸˜o ASSIGN e comando GO TO atribu´ e uso de um inteiro atribu´ por ASSIGN em uma
ca
ıdo
ıdo
declara¸˜o FORMAT.
ca
ˆ Desvio para uma declara¸˜o END IF a partir de um ponto fora do bloco.
ca
ˆ Comando PAUSE.
ˆ Descritor de edi¸˜o H.
ca
1.4
O Fortran no S´culo XXI: Fortran 2003
e
O Fortran 2003 ´ novamente uma revis˜o grande do padr˜o anterior: Fortran 95. A vers˜o curta (draft) do
e
a
a
a
novo padr˜o foi divulgada em finais de 20033 e tornou-se desde ent˜o o novo padr˜o da linguagem, embora at´
a
a
a
e
o presente momento nenhum compilador apresenta suporte completo do novo padr˜o. As grandes novidades
a
introduzidas foram: um direcionamento ainda maior para programa¸˜o orientada a objeto, a qual oferece
ca
uma maneira efetiva de separar a programa¸˜o de um c´digo grande e complexo em tarefas independentes
ca
o
e que permite a constru¸˜o de novo c´digo baseado em rotinas j´ existentes e uma capacidade expandida
ca
o
a
de interface com a linguagem C, necess´ria para que os programadores em Fortran possam acessar rotinas
a
escritas em C e para que programadores de C possam acessar rotinas escritas em Fortran.
Esta Apostila n˜o ir´ abordar os novos recursos introduzidos pelo Fortran 2003, limitando-se a list´-los.
a a
a
3 Ver
o draft em: http://www.dkuug.dk/jtc1/sc22/open/n3661.pdf.
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

14. 6
1.4. O Fortran no S´culo XXI: Fortran 2003
e
1.4.1
Recursos novos do Fortran 2003
Os principais recursos introduzidos pelo padr˜o s˜o:
a a
ˆ Aprimoramentos dos tipos derivados: tipos derivados parametrizados, controle melhorado de acessibilidade, construtores de estrutura aperfei¸oados e finalizadores.
c
ˆ Suporte para programa¸˜o orientada a objeto: extens˜o de tipo e heran¸a (inheritance), polimorfismo
ca
a
c
(polymorphism), aloca¸˜o dinˆmica de tipo e rotinas (procedures) ligadas a tipo.
ca
a
ˆ Aperfei¸oamentos na manipula¸˜o de dados: componentes aloc´veis de estruturas, argumentos mudos
c
ca
a
aloc´veis, parˆmetros de tipo deferidos (deferred type parameters), atributo VOLATILE, especifica¸˜o
a
a
ca
expl´
ıcita de tipo em construtores de matrizes e declara¸˜es de aloca¸˜o, aperfei¸oamentos em ponteiros,
co
ca
c
express˜es de inicializa¸˜o estendidas e rotinas intr´
o
ca
ınsecas aperfei¸oadas.
c
ˆ Aperfei¸oamentos em opera¸˜es de Entrada/Sa´ (E/S) de dados: transferˆncia ass´
c
co
ıda
e
ıncrona, acesso
de fluxo (stream access), opera¸˜es de transferˆncia especificadas pelo usu´rio para tipos derivados,
co
e
a
controle especificado pelo usu´rio para o arredondamento em declara¸˜es FORMAT, constantes nomeadas
a
co
para unidades pr´-conectadas, o comando FLUSH, regulariza¸˜o de palavras-chave e acesso a mensagens
e
ca
de erro.
ˆ Ponteiros de rotinas (procedure pointers).
ˆ Suporte para as exce¸˜es do padr˜o de aritm´tica bin´ria de ponto flutuante ISO/IEC 559, anteriorco
a
e
a
mente conhecido como padr˜o IEEE 754.
a
ˆ Interoperabilidade com a linguagem de programa¸˜o C.
ca
ˆ Suporte aperfei¸oado para internacionaliza¸˜o: acesso ao conjunto de caracteres de 4 bytes ISO 10646
c
ca
and escolha de v´
ırgula ou ponto como separador de parte inteira e parte decimal em opera¸˜es de E/S
co
num´ricas formatadas.
e
ˆ Integra¸˜o aperfei¸oada com o sistema operacional hospedeiro: acesso a argumentos de linha de coca
c
mando, vari´veis de ambiente e mensagens de erro do processador.
a
1.4.2
Recursos em obsolescˆncia do Fortran 2003
e
Nesta lista permanecem ´
ıtens que j´ estavam na lista de obsolescˆncia do Fortran 95. Os crit´rios para
a
e
e
inclus˜o nesta lista continuam sendo: recursos redundantes e para os quais m´todos melhores estavam
a
e
dispon´
ıveis no Fortran 95. A lista dos ´
ıtens em obsolescˆncia do Fortran 2003 ´:
e
e
ˆ IF aritm´tico.
e
ˆ END DO compartilhado por dois ou mais la¸os e t´rmino de um la¸o em uma cl´usula distinta de END
c
e
c
a
DO ou CONTINUE.
ˆ RETURN alternativo.
ˆ Comando GO TO computado.
ˆ Fun¸˜es definidas em uma linha (statement functions).
co
ˆ Declara¸˜es DATA entre comandos execut´veis.
co
a
ˆ Fun¸˜es de caractere de extens˜o assumida.
co
a
ˆ Formato fixo da fonte.
ˆ Forma CHARACTER* da declara¸˜o CHARACTER.
ca
1.4.3
Recursos removidos do Fortran 2003
Um recurso ´ removido do novo padr˜o se este for considerado redundante e praticamente sem uso pela
e
a
comunidade, devido a novos recursos muito mais uteis na constru¸˜o do c´digo.
´
ca
o
A lista de recursos removidos no Fortran 2003, divulgada no draft, repete os recursos removidos do
Fortran 95. Portanto, nenhum outro recurso foi removido.
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

15. Cap´
ıtulo 1. Introdu¸˜o
ca
1.5
7
O novo padr˜o: Fortran 2008
a
Embora ainda n˜o exista nenhum compilador que suporte completamente o padr˜o atual, Fortran 2003,
a
a
j´ est´ em fase de conclus˜o as discuss˜es a respeito do padr˜o futuro: Fortran 2008. A vers˜o curta (draft)
a
a
a
o
a
a
do novo padr˜o deve ser divulgada ao final do ano de 2008.
a
O Fortran 2008, embora pelo procedimento adotado pelos comitˆs X3J3/WG5 devesse ser uma revis˜o
e
a
menor do Fortran 2003, pode vir a apresentar algumas novidades substanciais, tais como as co-matrizes (coarrays). Os detalhes completos dos novos recursos ainda n˜o foram plenamente divulgados para o p´blico
a
u
em geral, mas alguns dos ´
ıtens que ir˜o compor o novo padr˜o, por consenso, est˜o listados a seguir.
a
a
a
1.5.1
Recursos novos do Fortran 2008
Com base em material de divulga¸˜o obtido na World Wide Web, os seguintes recursos ser˜o inclu´
ca
a
ıdos:
ˆ Co-matrizes (co-arrays).
ˆ BITS, originalmente denominados objetos sem tipo (TYPELESS).
ˆ Macros inteligentes (no lugar de m´dulos parametrizados).
o
ˆ Atributo CONTIGUOUS.
ˆ La¸os DO concorrentes (DO CONCURRENT).
c
ˆ Interoperabilidade de ponteiros, objetos aloc´veis, matrizes de forma assumida e argumentos opcionais.
a
ˆ Execu¸ao de programas externos.
c˜
ˆ Ponteiro aloc´vel em resolu¸˜o gen´rica
a
ca
e
ˆ Rotina interna como argumento real
ˆ Inicializa¸˜o de ponteiros com alvos distintos de NULL().
ca
ˆ Rotinas intr´
ınsecas estendidas.
ˆ Opera¸˜o de E/S recursivas a distintas unidades.
ca
ˆ ...
1.6
Coment´rios sobre a bibliografia
a
Para escrever esta apostila, fiz uso de um n´mero restrito de publica¸˜es, algumas das quais s˜o de livre
u
co
a
acesso atrav´s da internet.
e
ˆ Para informa¸˜es a respeito do padr˜o existente na linguagem Fortran 77, a qual foi substitu´ pelo
co
a
ıda
Fortran 90/95, utilizei freq¨entemente o livro de Clive Page: Professional Programer’s Guide to Fortran
u
77 [5].
ˆ A principal fonte de informa¸˜o sobre o padr˜o do Fortran 90/95 foi o amplo livro de Michael Metcalf
ca
a
e John Reid: Fortran 90/95 Explained [4].
ˆ O curso virtual de Fortran 90 oferecido pela Universidade de Liverpool [3].
ˆ O curso virtual de Fortran 90 para programadores que j´ conhecem o Fortran 77, oferecido pela
a
Universidade de Manchester [6].
ˆ O manual de referˆncia ` Linguagem Fortran 90/95 que acompanha o compilador intel tamb´m foi
e
a
e
freq¨entemente consultado [1].
u
ˆ Informa¸˜es divulgadas sobre o Fortran 2003 foram obtidas do livreto de John Reid [7] e do livro de
co
Stephen Chapman: Fortran 95/2003 for Scientists and Engineers [2].
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

16. 8
1.7
1.7. Observa¸˜es sobre a apostila e agradecimentos
co
Observa¸˜es sobre a apostila e agradecimentos
co
Por se tratar de uma obra em constante revis˜o, esta apostila pode conter (e conter´, invariavelmente)
a
a
uma s´rie de erros de ortografia, pontua¸˜o, acentua¸˜o, etc. Em particular, o texto n˜o foi ainda revisado
e
ca
ca
a
para se conformar com o novo acordo ortogr´fico da Lingua Portuguesa. Certos pontos poderiam tamb´m
a
e
ser melhor discutidos e podem conter at´ informa¸˜es n˜o completamente corretas.
e
co
a
Durante o desenvolvimento e divulga¸˜o desta apostila, algumas pessoas contribuiram com o seu aprica
moramento ao apontar erros e inconsistˆncias e ao oferecer sugest˜es quanto a sua estrutura e conte´do.
e
o
u
Qualquer contribui¸˜o ´ bem vinda e pode ser enviada ao endere¸o eletrˆnico: rudi@ufpel.edu.br.
ca e
c
o
Gostaria de agradecer publicamente as contribui¸˜es das seguintes pessoas: Leandro Tezani.
co
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

17. Cap´
ıtulo 2
Formato do C´digo-Fonte
o
Neste cap´
ıtulo estuda-se, inicialmente, um formato b´sico para o programa-fonte em Fortran 90/95 e os
a
tipos de vari´veis e suas caracter´
a
ısticas b´sicas.
a
2.1
Formato do programa-fonte
Em Fortran h´ trˆs formatos b´sicos de arquivos que s˜o utilizados:
a e
a
a
Programa-Fonte. Trata-se do programa e/ou dos subprogramas escritos pelo programador, usando algum
tipo de editor de texto, de acordo com as regras definidas pela linguagem de programa¸˜o de alto
ca
n´
ıvel.
Programa-Objeto. Trata-se do programa-fonte compilado pelo compilador. Esta ´ a transcri¸˜o realizada
e
ca
pelo compilador do programa-fonte fornecido pelo programador para uma linguagem de baixo n´
ıvel,
como Assembler ou outro c´digo diretamente interpret´vel pela CPU. O programa-objeto n˜o pode
o
a
a
ainda ser executado; ´ necess´rio ainda passar-se pela fase do linking (tradu¸˜o livre: linkagem).
e
a
ca
Programa execut´vel. Ap´s a fase de compila¸˜o, onde os programas objetos s˜o criados, o agente de
a
o
ca
a
compila¸˜o aciona o linker, o qual consiste em um programa especial que agrupa os programas objetos
ca
de forma a criar um arquivo final, o programa execut´vel, o qual pode ser ent˜o executado pelo
a
a
programador.
Nesta se¸˜o ser´ apresentada a estrutura b´sica de um programa-fonte em Fortran 90/95.
ca
a
a
O Fortran 90/95 suporta duas formas de c´digo-fonte: o formato antigo do Fortran 77, agora denominado
o
formato fixo e o novo formato livre.
Fortran 77: O formato fixo foi utilizado pelo Fortran desde a primeira vers˜o at´ o Fortran 77. Este
a
e
formato foi determinado pelas restri¸˜es impostas pelos cart˜es perfurados, que eram a unica op¸˜o para
co
o
´
ca
entrar com o c´digo fonte. A estrutura do formato fixo ´ a seguinte:
o
e
Colunas 1-5: r´tulos (labels) para desvio de processamento do programa.
o
Coluna 6: caractere de continua¸˜o de linha.
ca
Colunas 7-72: c´digo fonte.
o
H´, ainda, a possibilidade de incluir o caractere “C” ou “c” na coluna 1, o que instrui o compilador a ignorar
a
tudo que segue neste linha. Esta ´ a forma encontrada para se colocar coment´rios dentro do c´digo fonte.
a
a
o
Fortran 90/95: Nestas revis˜es, a linguagem passou a suportar o formato livre, com as seguintes caraco
ter´
ısticas.
ˆ No formato livre n˜o h´ uma coluna espec´
a a
ıfica para iniciar o programa. Pode-se come¸ar a escrever
c
o c´digo a partir da coluna 1 e a linha de c´digo pode se estender at´ a coluna 132. Al´m disso, os
o
o
e
e
caracteres em branco s˜o irrelevantes em qualquer lugar do c´digo, exceto quanto estiverem sendo
a
o
utilizados entre ap´strofes. Neste caso, cada caractere em branco ser´ avaliado na composi¸˜o final do
o
a
ca
string.
9

18. 10
2.1. Formato do programa-fonte
ˆ Mais de uma instru¸˜o pode ser colocada na mesma linha. O separador de linhas padr˜o ´ o pontoca
a e
e-v´
ırgula “;”. M´ltiplos “;” em uma linha, com ou sem brancos, s˜o considerados como um separador
u
a
simples. Desta forma, a seguinte linha de c´digo ´ interpretada como 3 linhas em seq¨ˆncia:
o
e
ue
A = 0; B = 0; C = 0
ˆ O caractere ampersand “&” ´ a marca de continua¸˜o, isto ´, ele indica que a linha com instru¸˜es
e
ca
e
co
imediatamente posterior ´ continua¸˜o da linha onde o “&” foi digitado. Desta forma, s˜o permitidas
e
ca
a
at´ 39 linhas adicionais de c´digo. Como exemplo, a seguinte linha de c´digo:
e
o
o
X = (-Y + ROOT_OF_DISCRIMINANT)/(2.0*A)
tamb´m pode ser escrita usando o “&”:
e
X =
(-Y + ROOT_OF_DISCRIMINANT)
/(2.0*A)
&
&
ˆ Para entrar com coment´rios em qualquer ponto do c´digo-fonte, o usu´rio deve digitar o ponto de
a
o
a
exclama¸˜o “!” em qualquer coluna de uma linha. Todo o restante da linha ser´ desprezado pelo
ca
a
compilador. Exemplo:
X = Y/A - B ! Soluciona a equa¸~o linear.
ca
O programa “Alˆ Mam˜e”.
o
a
Como primeiro exemplo de programa em Fortran 90/95, considere o seguinte c´digo-fonte:
o
program p r i m e i r o
i m p l i c i t none
print * , ”Alˆ Mam˜e”
o
a
end program p r i m e i r o
A forma mais simples de um programa em Fortran 90/95 ´ a seguinte:
e
PROGRAM <nome_do_programa>
<declara¸~es de nomes de vari´veis>
co
a
<comandos execut´veis>
a
END PROGRAM <nome_do_programa>
Comparando com o exemplo do programa primeiro, a declara¸˜o
ca
PROGRAM primeiro
´ sempre a primeira instru¸˜o de um programa. Ela serve para identificar o c´digo ao compilador.
e
ca
o
Em seguida vˆm as declara¸~es de nomes de vari´veis. Neste ponto, s˜o definidos os nomes das
e
co
a
a
vari´veis a ser usadas pelo programa. Caso n˜o seja necess´rio declarar vari´veis, como no programa
a
a
a
a
primeiro, ´ recomend´vel incluir, pelo menos, a instru¸˜o implicit none. Esta instrui o compilador a
e
a
ca
exigir que todas as vari´veis usadas pelo programa tenham o seu tipo explicitamente definido.1
a
Ap´s declaradas as vari´veis, vˆm os comandos execut´veis. No caso do programa primeiro, o unico
o
a
e
a
´
comando execut´vel empregado foi
a
print *, “Al^ Mam~e”
o
a
o qual tem como conseq¨ˆncia a impress˜o do texto “Alˆ Mam˜e” na tela do monitor, o qual ´ a chamada
ue
a
o
a
e
sa´ padr˜o.
ıda
a
Finalmente, o programa ´ encerrado com a instru¸˜o
e
ca
end program primeiro
Os recursos utilizados no programa primeiro ser˜o explicados com mais detalhes neste e nos pr´ximos
a
o
cap´
ıtulos da apostila.
1 Os
tipos de vari´veis suportados pelo Fortran 95 s˜o discutidos no cap´
a
a
ıtulo 3.
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

19. Cap´
ıtulo 2. Formato do C´digo-Fonte
o
2.2
11
Nomes em Fortran 90/95
Um programa em Fortran 90/95 faz referˆncia a muitas entidades distintas, tais como programas, sube
programas, m´dulos, vari´veis, etc. Os nomes destas entidades devem consistir em caracteres alfanum´ricos,
o
a
e
de 1 a 31 caracteres. Os caracteres alfanum´ricos v´lidos s˜o:
e
a
a
ˆ Letras (a - z; A - Z).
ˆ Numerais (0 - 9).
ˆ O caractere underscore “ ”.
A unica restri¸˜o ´ que o primeiro caractere seja uma letra. Os seguintes exemplos s˜o v´lidos:
´
ca e
a a
A
A_COISA
X1
MASSA
Q123
TEMPO_DE_VOO
j´ estes exemplos n˜o s˜o v´lidos:
a
a a a
1A (come¸a com numeral)
c
A COISA (espa¸o em branco)
c
$SINAL (cont´m caractere n˜o alfanum´rico).
e
a
e
2.3
Entrada e sa´ padr˜es
ıda
o
O Fortran 90 possui trˆs comandos de entrada/sa´ de dados. A maneira mais direta de definir valores
e
ıda
de vari´veis ou de exibir os valores destas ´ atrav´s dos dispositivos de entrada/sa´ padr˜es.
a
e
e
ıda
o
O dispositivo padr˜o de entrada de dados ´ o teclado. O comando de leitura para o programa ler os
a
e
valores das vari´veis ´:
a
e
READ *, <lista de nomes de vari´veis>
a
READ(*,*) <lista de nomes de vari´veis>
a
onde na lista de nomes de vari´veis est˜o listados os nomes das vari´veis que dever˜o receber seus
a
a
a
a
valores via teclado. O usu´rio deve entrar com os valores das vari´veis separando-as por v´
a
a
ırgulas.
O dispositivo padr˜o de sa´ de dados ´ a tela do monitor. H´ dois comandos de sa´ padr˜o de dados:
a
ıda
e
a
ıda
a
PRINT *, [’<mensagem>’[,]][<lista de nomes de vari´veis>]
a
WRITE(*,*) [’<mensagem>’[,]][<lista de nomes de vari´veis>]
a
O programa a seguir instrui o computador a ler o valor de uma vari´vel real a partir do teclado e, ent˜o,
a
a
imprimir o valor desta na tela do monitor:
program l e v a l o r
i m p l i c i t none
real : : a
print * , ”I n f o r m e o v a l o r de a : ”
read * , a
print * , ”Valor l i d o : ” , a
end program l e v a l o r
No programa acima, foi declarada a vari´vel real a, cujo valor ser´ lido pelo computador, a partir do teclado,
a
a
´
e ent˜o impresso na tela do monitor. E importante salientar que a instru¸˜o implicit none deve ser sempre
a
ca
a segunda linha de um programa, sub-programa ou m´dulo, aparecendo antes do restante das declara¸˜es
o
co
de vari´veis.
a
Esta se¸˜o apresentou somente um uso muito simples dos recursos de Entrada/Sa´ de dados. Uma
ca
ıda
descri¸˜o mais completa destes recursos ser´ realizada no cap´
ca
a
ıtulo 9 na p´gina 121.
a
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

20. 12
2.4. Conjunto de caracteres aceitos
Tabela 2.1: Caracteres especiais do Fortran 90/95
Caractere
=
+
*
/
(
)
,
.
$
:
2.4
Nome/Fun¸˜o
ca
Igual
Soma
Subtra¸˜o
ca
Multiplica¸˜o
ca
Divis˜o
a
Parˆnteses esquerdo
e
Parˆnteses direito
e
V´
ırgula
Ponto decimal
Cifr˜o
a
Dois pontos
Caractere
!
“
%
&
;
?
**
’
<
>
Nome/Fun¸˜o
ca
Espa¸o em branco
c
Exclama¸˜o
ca
Aspas
Porcentagem
E comercial (ampersand)
Ponto e v´
ırgula
Ponto de interroga¸˜o
ca
Potˆncia
e
Ap´strofe
o
Menor que
Maior que
Conjunto de caracteres aceitos
No Fortran 90/95, os elementos b´sicos, denominados de tokens, s˜o os caracteres alfanum´ricos, os 10
a
a
e
d´
ıgitos ar´bicos, o underscore “ ” e o conjunto de caracteres especiais apresentados na tabela 2.1. Dentro da
a
sintaxe da linguagem, n˜o existem diferen¸as entre letras mai´sculas e min´sculas.
a
c
u
u
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

21. Cap´
ıtulo 3
Tipos de Vari´veis
a
Em Fortran, h´ cinco tipos intr´
a
ınsecos de vari´veis: trˆs tipos num´ricos, inteiros, reais e complexos (em
a
e
e
inglˆs INTEGER, REAL e COMPLEX) e dois tipos n˜o num´ricos, caracteres e l´gicos (em inglˆs CHARACTER e
e
a
e
o
e
LOGICAL). O primeiro grupo de vari´veis ´ utilizado em opera¸˜es matem´ticas e ´ o mais utilizado. O
a
e
co
a
e
segundo grupo ´ utilizado para opera¸˜es que envolvem manipula¸˜es de texto ou opera¸˜es l´gicas.
e
co
co
co o
Em Fortran 90/95, cada um dos cinco tipos intr´
ınsecos possui um valor inteiro n˜o negativo denominado
a
parˆmetro de esp´cie do tipo (em inglˆs, kind type parameter ). A norma padr˜o da linguagem determina
a
e
e
a
que qualquer processador deve suportar pelo menos duas esp´cies para os tipos REAL e COMPLEX e pelo menos
e
uma esp´cie para os tipos INTEGER, CHARACTER e LOGICAL.
e
Um outro avan¸o do Fortran 90 sobre o predecessor Fortran 77 consiste na habilidade em definir novos
c
tipos de vari´veis, baseados nos tipos intr´
a
ınsecos. Estas s˜o os chamados tipos derivados ou estruturas, os
a
quais consistem em combina¸˜es de partes compostas por tipos intr´
co
ınsecos e/ou por outros tipos derivados,
permitindo gerar objetos de complexidade crescente.
Neste cap´
ıtulo, vamos inicialmente definir o uso b´sicos dos tipos intr´
a
ınsecos de vari´veis, seguindo pela
a
defini¸˜o das esp´cies de vari´veis mais comuns, terminando por definir os tipos derivados.
ca
e
a
3.1
Declara¸˜o de tipo de vari´vel
ca
a
Como j´ foi colocado anteriormente, ´ uma boa praxe de programa¸˜o iniciar o setor de declara¸˜es de
a
e
ca
co
vari´veis com a declara¸˜o
a
ca
IMPLICIT NONE
a qual impede a possibilidade de haver nomes de vari´veis n˜o definidos, os quais possuem o seu tipo
a
a
impl´
ıcito, uma pr´tica corriqueira em Fortran 77.
a
A forma geral de uma declara¸˜o de tipo de vari´veis ´:
ca
a
e
<tipo>[([KIND=]<par^metro de esp´cie>)][,<lista de atributos>] ::
a
e
<lista de entidades>
onde <tipo> especifica o tipo de vari´vel, <par^metro de esp´cie> especifica a esp´cie da vari´vel, <lista
a
a
e
e
a
de atributos> ´ um dos seguintes:
e
PARAMETER
PUBLIC
PRIVATE
POINTER
TARGET
ALLOCATABLE
DIMENSION(<lista de extens~es>)
o
INTENT(<inout>)
OPTIONAL
SAVE
EXTERNAL
INTRINSIC
e cada entidade ´
e
<nome do objeto> [(lista de extens~es)] [*char-len] [= express~o de inicializa¸~o]
o
a
ca
ou
<nome da fun¸~o> [*char-len]
ca
onde <nome do objeto> ´ o nome da vari´vel, seguindo a regra de nomes v´lidos definida no cap´
e
a
a
ıtulo 2.
Os objetos restantes, em particular <par^metro de esp´cie> e <lista de atributos>, ser˜o estudados
a
e
a
ao longo do desenvolvimento desta apostila.
13

22. 14
3.2. Vari´veis do tipo INTEGER
a
3.2
Vari´veis do tipo INTEGER
a
Este tipo de vari´vel armazena apenas a parte inteira de um n´mero, exemplos de n´meros inteiros
a
u
u
v´lidos, tamb´m denominados literais s˜o:
a
e
a
123, 89312, 5.
As declara¸˜es b´sicas de nomes de vari´veis de tipo inteiro s˜o:
co
a
a
a
Fortran 77: INTEGER <lista de nomes de vari´veis>
a
Fortran 90/95: INTEGER ::
<lista de nomes de vari´veis>
a
O tipo de dados inteiro possui valores que pertencem ao conjunto dos n´meros inteiros.
u
Programa exemplo:
program i n t e i r o
i m p l i c i t none
integer : : x
! O v a l o r d i g i t a d o n˜ o pode c o n t e r ponto ( . ) Caso i s t o
a
! aco nte¸ a , v a i g e r a r um e r r o de e x e c u ¸ ˜ o no programa ,
c
ca
! a b o r t a n d o o mesmo .
read * , x
print * , ”Valor l i d o : ” , x
end program i n t e i r o
3.3
Vari´veis do tipo REAL
a
O tipo de vari´vel real ´ composto de quatro partes, assim dispostas:
a
e
1. uma parte inteira, com ou sem sinal,
2. um ponto decimal,
3. uma parte fracion´ria e
a
4. um expoente, tamb´m com ou sem sinal.
e
Um ou ambos os itens 1 e 3 devem estar presentes. O item 4 ou est´ ausente ou consiste na letra E seguida
a
por um inteiro com ou sem sinal. Um ou ambos os itens 2 e 4 devem estar presentes. Exemplos de literais
reais s˜o:
a
-10.6E-11 (representando −10, 6 × 10−11 )
1.
-0.1
1E-1 (representando 10−1 ou 0,1)
3.141592653
Os literais reais s˜o representa¸˜es do conjunto dos n´meros reais e o padr˜o da linguagem n˜o especifica
a
co
u
a
a
o intervalo de valores aceitos para o tipo real e nem o n´mero de d´
u
ıgitos significativos na parte fracion´ria
a
(item 3) que o processador suporta, uma vez que estes valores dependem do tipo de processador em uso.
Valores comuns s˜o: intervalo de n´meros entre 10−38 a 10+38 , com uma precis˜o de cerca de 7 (sete) d´
a
u
a
ıgitos
decimais.
As declara¸˜es b´sicas do tipo real s˜o:
co
a
a
Fortran 77: REAL <lista de nomes de vari´veis>
a
Fortran 90/95: REAL ::
<lista de nomes de vari´veis>
a
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

23. Cap´
ıtulo 3. Tipos de Vari´veis
a
15
Programa exemplo:
program v a r r e a l
i m p l i c i t none
r e a l : : a , b= 1 0 . 5 e−2 ! V a r i ´ v e l b ´ i n i c i a l i z a d a a 1 0 . 5 e −2.
a
e
print * , ’ Valor de a : ’
read * , a
print * , ’ Valor de a : ’ , a
print * , ’ Valor de b : ’ , b
end program v a r r e a l
3.4
Vari´veis do tipo COMPLEX
a
O Fortran, como uma linguagem destinada para c´lculos cient´
a
ıficos ou em engenharia, tem a vantagem
de possuir um terceiro tipo intr´
ınseco: n´meros complexos. Este tipo ´ concebido como um par de literais,
u
e
os quais s˜o ou inteiros ou reais, separados por v´
a
ırgula “,” e contidos entre parˆnteses “(“ e “)”. Os literais
e
complexos representam n´meros contidos no conjunto dos n´meros complexos, isto ´, n´meros do tipo
u
u
e u
√
e
e
a
u
z = x + iy, onde i = −1, x ´ a parte real e y ´ a parte imagin´ria do n´mero complexo z. Assim, um
literal complexo deve ser escrito:
(<parte real>,<parte imagin´ria>)
a
Exemplos de literais complexos s˜o:
a
(1.,3.2) (representando 1 + 3, 2i)
(1.,.99E-2) (representando 1 + 0, 99 × 10−2 i)
(1.0,-3.7)
Uma outra grande vantagem do Fortran ´ que toda a ´lgebra de n´meros complexos j´ est´ implementada
e
a
u
a a
a n´ de compilador. Assim, se for realizado o produto de dois n´meros complexos (x1,y1) e (x2,y2), o
ıvel
u
resultado ser´ o literal complexo dado por (x1*x2 - y1*y2,x1*y2 + x2*y1). O mesmo acontecendo com
a
as outras opera¸˜es alg´bricas.
co
e
As declara¸˜es b´sicas do tipo complexo s˜o:
co
a
a
Fortran 77: COMPLEX <lista de nomes de vari´veis>
a
Fortran 90/95: COMPLEX ::
<lista de nomes de vari´veis>
a
Programa exemplo:
program va r c o m pl ex a
i m p l i c i t none
complex : : a= (5 , −5) , b , c ! V a r i ´ v e l a ´ i n i c i a l i z a d a a (5 , −5).
a
e
print * , ”Valor de b : ”
! O v a l o r de b d e v e s e r e n t r a d o como um l i t e r a l complexo .
! Exemplo : ( − 1 . 5 , 2 . 5 )
read * , b
c= a * b
print * , ”O v a l o r de c : ” , c
! V e r i f i q u e o r e s u l t a d o no p a p e l .
end program va r c o m pl ex a
3.5
Vari´veis do tipo CHARACTER
a
O tipo padr˜o consiste em um conjunto de caracteres contidos em um par de ap´strofes ou aspas. Os
a
o
caracteres n˜o est˜o restritos ao conjunto de caracteres padr˜o definidos na se¸˜o 2.4. Qualquer caractere
a
a
a
ca
que possa ser representado pelo processador ´ aceito, exceto os caracteres de controle tais como o return.
e
Os ap´strofes ou aspas servem como delimitadores dos literais de caractere e n˜o s˜o considerados parte
o
a a
integrante do conjunto. Ao contr´rio das normas usuais, um espa¸o em branco ´ diferente de dois ou mais.
a
c
e
Exemplos de literais de caractere:
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

24. 16
3.6. Vari´veis do tipo LOGICAL
a
’bom Dia’
’bomDia’
’BRASIL’
“Fortran 90”
As declara¸˜es mais utilizadas para o tipo caractere s˜o:
co
a
Fortran 77: character*<comprimento> <lista de nomes de vari´veis>
a
ou
character <nome 1>*<comp. 1>, [<nome 2>*<comp. 2>, ...]
Fortran 90/95: character(len=<comprimento>) ::
<lista de nomes de vari´veis>
a
onde <comprimento> indica a quantidade de caracteres contidos nas vari´veis. Todas as vari´veis definidas
a
a
por esta declara¸˜o tˆm o mesmo n´mero de caracteres. Se for informado um literal maior que <comprica e
u
mento>, este ser´ truncado; se for informado um literal menor que o declarado, o processador ir´ preencher
a
a
o espa¸o restante ` direita com espa¸os em branco.
c
a
c
Programa exemplo:
program l e c a r a c t e r e
i m p l i c i t none
character ( len =10) : : s t r r e a d
print * , ”Entre com t e x t o ” :
read ’ ( a ) ’ , s t r r e a d
print * , ”Texto l i d o : ” , s t r r e a d
end program l e c a r a c t e r e
´
E importante mencionar aqui a regra particular para o formato de fonte dos literais de caractere que s˜o
a
escritos em mais de uma linha:
1. Cada linha deve ser encerrada com o caractere “&” e n˜o pode ser seguida por coment´rio.
a
a
2. Cada linha de continua¸˜o deve ser precedida tamb´m pelo caractere “&”.
ca
e
3. Este par “&&” n˜o faz parte do literal.
a
4. Quaisquer brancos seguindo um & em final de linha ou precedendo o mesmo caractere em in´
ıcio de
linha n˜o s˜o partes do literal.
a a
5. Todo o restante, incluindo brancos, fazem parte do literal.
Como exemplo temos:
car_longo =
’O tempo que eu hei sonhado
& Quantos anos foi de vida!
& Ah, quanto do meu passado
& Foi s´ a vida mentida
o
& De um futuro imaginado!
&
& Aqui ` beira do rio
a
& Sossego sem ter raz~o.
a
& Este seu correr vazio
& Figura, an^nimo e frio,
o
& A vida, vivida em v~o.’
a
3.6
&
&
&
&
&
&
&
&
&
&
&
Vari´veis do tipo LOGICAL
a
O tipo l´gico define vari´veis l´gicas. Uma vari´vel l´gica s´ pode assumir dois valores, verdadeiro e
o
a
o
a
o
o
falso. A representa¸˜o dos dois estado poss´
ca
ıveis de uma vari´vel l´gica s˜o:
a
o
a
ˆ .TRUE. ⇒ Verdadeiro
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

25. Cap´
ıtulo 3. Tipos de Vari´veis
a
17
ˆ .FALSE. ⇒Falso.
As declara¸˜es do tipo l´gico s˜o:
co
o
a
Fortran 77: logical <lista de nomes de vari´veis>
a
Fortran 90/95: logical ::
<lista de nomes de vari´veis>
a
Programa exemplo:
program l o g i c o
i m p l i c i t none
l o g i c a l : : a= . t r u e .
i f ( a ) then
print * , ”A v a r i ´ v e l ´ v e r d a d e i r a . ”
a
e
end i f
end program l o g i c o
3.7
O conceito de esp´cie (kind)
e
Em Fortran, al´m dos 5 tipos de vari´veis definidos nas se¸˜es 3.2 a 3.6, ´ poss´ definir extens˜es a
e
a
co
e
ıvel
o
um determinado tipo, cujas declara¸˜es dependem da vers˜o do Fortran utilizada e do processador no qual
co
a
o programa ser´ executado.
a
3.7.1
Fortran 77
Em Fortran 77 as extens˜es mais comuns e as correspondentes declara¸˜es s˜o:
o
co
a
ˆ vari´veis reais de precis˜o dupla: real*8 <lista de nomes de vari´veis> ou double precision
a
a
a
<lista de nomes de vari´veis>.
a
ˆ vari´veis reais de precis˜o estendida (ou qu´drupla): real*16 <lista de nomes de vari´veis>.
a
a
a
a
ˆ vari´veis complexas de precis˜o dupla: complex*16 <lista de nomes de vari´veis>.
a
a
a
As diferen¸as entre estas extens˜es e os correspondentes tipos originais ser˜o ilustradas a seguir.
c
o
a
3.7.2
Fortran 90/95
Em Fortran 90/95, cada um dos cinco tipos intr´
ınsecos, INTEGER, REAL, COMPLEX, CHARACTER e LOGICAL possui associado um valor inteiro n˜o negativo denominado parˆmetro de esp´cie do tipo (kind type
a
a
e
parameter). Por exigˆncia do padr˜o, um processador deve suportar, no m´
e
a
ınimo, duas esp´cies para os tipos
e
REAL e COMPLEX e uma esp´cie para os tipos INTEGER, CHARACTER e LOGICAL.
e
Os valores da esp´cie s˜o dependentes do processador e/ou do compilador empregado. Contudo, h´
e
a
a
fun¸˜es intr´
co
ınsecas fornecidas pelo compilador que verificam as precis˜es suportadas pelo processador e que
o
podem ser usadas para definir o valor do parˆmetro KIND, possibilitando assim a portabilidade do c´digo,
a
o
isto ´, a possibilidade deste rodar em diferentes arquiteturas usando uma precis˜o m´
e
a
ınima especificada pelo
programador.
Para demonstrar como diferentes compiladores implementam e usam o parˆmetro de esp´cie, ser˜o cona
e
a
siderados os compiladores Intel® Fortran Compiler for linux (vers˜o 9.1), gfortran e o compilador
a
F, todos gratu´
ıtos.
3.7.2.1
Compilador Intel® Fortran
O compilador Intel® Fortran oferece os seguintes tipos intr´
ınsecos, juntamente com as respectivas
declara¸˜es de tipo e esp´cie:
co
e
Tipo Inteiro. H´ 04 parˆmetros de esp´cie para o tipo inteiro.
a
a
e
Declara¸˜o: INTEGER([KIND=]<n>) [::] <lista de nomes de vari´veis>
ca
a
Sendo <n> das esp´cies 1, 2, 4 ou 8. Se o parˆmetro de esp´cie ´ explicitado, as vari´veis na <lista de
e
a
e e
a
nomes de vari´veis> ser˜o da esp´cie escolhida. Em caso contr´rio, a esp´cie ser´ o inteiro padr˜o:
a
a
e
a
e
a
a
INTEGER(KIND=4); ou seja, a declara¸˜o INTEGER :: <lista de nomes de vari´veis> equivale a
ca
a
INTEGER(KIND=4) :: <lista de nomes de vari´veis>.
a
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

26. 18
3.7. O conceito de esp´cie (kind)
e
® Fortran.
Tabela 3.1: Tabela de armazenamento de vari´veis para o compilador Intel
a
Tipo e Esp´cie
e
INTEGER(KIND=1)
INTEGER(KIND=2)
INTEGER(KIND=4)
INTEGER(KIND=8)
REAL(KIND=4)
REAL(KIND=8)
REAL(KIND=16)
Armazenamento (bytes)
1=8 bits
2
4
8
4
8
16
Tipo e Esp´cie
e
LOGICAL(KIND=1)
LOGICAL(KIND=2)
LOGICAL(KIND=4)
LOGICAL(KIND=8)
COMPLEX(KIND=4)
COMPLEX(KIND=8)
COMPLEX(KIND=16)
Armazenamento (bytes)
1
2
4
8
8
16
32
® Fortran.
Programa 3.1: Testa distintas esp´cies suportadas pelo compilador Intel
e
program t e s t a k i n d i n t e l
i m p l i c i t none
integer , parameter : : dp= 8 , qp= 16
real : : r s i m p l e s
r e a l ( kind= dp ) : : r d u p l a
r e a l ( kind= qp ) : : r quad
!
! C a l c u l a a r a i z quadrada de 2 em d i v e r s a s p r e c i s ˜ e s .
o
r s i m p l e s= s q r t ( 2 . 0 )
! Precis˜o simples
a
r d u p l a= s q r t ( 2 . 0 dp ) ! P r e c i s ˜ o d u p l a
a
r quad= s q r t ( 2 . 0 qp )
! P r e c i s ˜ o q u ´ d r u p l a ou e s t e n d i d a .
a
a
!
! Imprime r e s u l t a d o s na t e l a .
print * , r s i m p l e s
print * , r d u p l a
print * , r quad
!
end program t e s t a k i n d i n t e l
Tipo Real. H´ 03 parˆmetros de esp´cie para o tipo real.
a
a
e
Declara¸˜o: REAL([KIND=]<n>) [::] <lista de nomes de vari´veis>
ca
a
Sendo <n> igual a 4, 8 ou 16. Caso o parˆmetro de esp´cie n˜o seja especificado, a esp´cie ser´ o real
a
e
a
e
a
padr˜o: REAL(KIND= 4).
a
Tipo Complexo. H´ 03 parˆmetros de esp´cie para o tipo complexo.
a
a
e
Declara¸˜o: COMPLEX([KIND=]<n>) [::] <lista de nomes de vari´veis>
ca
a
Sendo <n> igual a 4, 8 ou 16. Caso o parˆmetro de esp´cie n˜o seja explicitado, a esp´cie ser´ o
a
e
a
e
a
complexo padr˜o: COMPLEX(KIND= 4).
a
Tipo L´gico. H´ 04 parˆmetros de esp´cie para o tipo l´gico.
o
a
a
e
o
Declara¸˜o: LOGICAL([KIND=]<n>) [::] <lista de nomes de vari´veis>
ca
a
Sendo <n> igual a 1, 2, 4 ou 8.
Tipo Caractere. H´ somente uma esp´cie do tipo caractere.
a
e
Declara¸˜o: CHARACTER([KIND=1],[LEN=]<comprimento>) [::]
ca
<lista de nomes de vari´veis>
a
Cada esp´cie distinta ocupa um determinado espa¸o de mem´ria na CPU. Para o compilador Intel®
e
c
o
Fortran, o espa¸o ocupado est´ descrito na tabela 3.1.
c
a
O programa 3.1 a seguir ilustra do uso e as diferen¸as de algumas op¸˜es de esp´cies de tipos de vari´veis.
c
co
e
a
O mesmo programa tamb´m indica o uso de alguns atributos na declara¸˜o de vari´veis, tais como na
e
ca
a
declara¸˜o
ca
INTEGER, PARAMETER ::
DP= 2
O atributo PARAMETER indica que as vari´veis declaradas nesta senten¸a devem se comportar como constantes
a
c
matem´ticas, isto ´, n˜o podem ser alteradas no programa por nenhuma atribui¸˜o de vari´veis (ver cap´
a
e a
ca
a
ıtulo
4). Na mesma declara¸˜o, j´ est´ sendo inicializado o valor do parˆmetro DP, sendo este igual a 2.
ca a
a
a
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

27. Cap´
ıtulo 3. Tipos de Vari´veis
a
19
Tabela 3.2: Tabela de armazenamento de vari´veis para o compilador gfortran da funda¸ao GNU.
a
c˜
Tipo e Esp´cie
e
INTEGER(KIND=1)
INTEGER(KIND=2)
INTEGER(KIND=4)
INTEGER(KIND=8)
INTEGER(KIND=16)1
REAL(KIND=4)
REAL(KIND=8)
REAL(KIND=10)
Armazenamento (bytes)
1=8 bits
2
4
8
16
4
8
10
Tipo e Esp´cie
e
LOGICAL(KIND=1)
LOGICAL(KIND=2)
LOGICAL(KIND=4)
LOGICAL(KIND=8)
LOGICAL(KIND=16)
COMPLEX(KIND=4)
COMPLEX(KIND=8)
COMPLEX(KIND=10)
Armazenamento (bytes)
1
2
4
8
16
8
16
20
O mesmo exemplo tamb´m ilustra o uso da fun¸˜o impl´
e
ca
ıcita SQRT(X):
R_SIMPLES= SQRT(2.0)
a qual calculou a raiz quadrada da constante 2.0 e atribuiu o resultado ` vari´vel R_SIMPLES.
a
a
3.7.2.2
Compilador gfortran
Gfortran ´ o compilador Fortran 95 da GNU (Funda¸˜o Gnu is Not Unix.), inicialmente desenvolvido
e
ca
como alternativa ao compilador f95 distribu´ pelas vers˜es comerciais do Unix. Atualmente, o gfortran
ıdo
o
´ parte integrante da plataforma de desenvolvimento de software GCC (GNU Compiler Collection), que
e
´ composta por compiladores de diversas linguagens distintas, tais como Fortran 95, C/C++, Java, Ada,
e
entre outros. O comando gfortran consiste simplesmente em um script que invoca o programa f951, o qual
traduz o c´digo-fonte para assembler, invocando em seguida o linkador e as bibliotecas comuns do pacote
o
GCC.
No gfortran, os parˆmetros de esp´cie s˜o determinados de forma semelhante ao compilador Intel®
a
e
a
Fortran, discutido na se¸˜o 3.7.2.1, ou seja, o parˆmetro indica o n´mero de bytes necess´rios para armaca
a
u
a
zenar cada vari´vel da respectiva esp´cie de tipo. As esp´cies suportadas pelo gfortran s˜o descritas na
a
e
e
a
tabela 3.2.
O programa testa_kind_gfortran a seguir (programa 3.2) ilustra o uso e as diferen¸as entre as diversas
c
esp´cies de tipos de dados no compilador gfortran.
e
3.7.2.3
Compilador F
Como exemplo do uso do parˆmetro de esp´cie, a tabela 3.3 ilustra os valores suportados pelo compilador
a
e
F, conforme fornecidos pelo guia do usu´rio2 . H´ duas possibilidades para os n´meros da esp´cie:
a
a
u
e
1. o modo padr˜o de opera¸˜o, tamb´m denominado seq¨encial, o qual pode, por´m, ser especificado
a
ca
e
u
e
explicitamente no momento da compila¸˜o com a chave -kind=sequential;
ca
2. o esquema de numera¸˜o bytes, o qual deve ser especificado no momento da compila¸˜o com a chave
ca
ca
-kind=byte:
alunos|fulano>F -kind=byte <nome programa>.f90 -o <nome programa>
O exemplo a seguir, programa testa_kind_F, ilustra do uso e as diferen¸as de algumas op¸˜es de esp´cies
c
co
e
de tipos de vari´veis.
a
program t e s t a k i n d F
i m p l i c i t none
integer , parameter : : dp= 2
real : : r s i m p l e s
r e a l ( kind= dp ) : : r d u p l a
complex : : c s i m p l e s
complex ( kind= dp ) : : c d u p l a
!
! C a l c u l a a r a i z quadrada de 2 em d i v e r s a s p r e c i s ˜ e s .
o
r s i m p l e s= s q r t ( 2 . 0 )
! Precis˜o simples
a
1 Em
2 The
plataformas de 64 bits, tais como a fam´ de processadores Intel® Core— 2.
ılia
F Compiler and Tools (http://www.fortran.com/imagine1/ftools.pdf).
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

28. 20
3.7. O conceito de esp´cie (kind)
e
Programa 3.2: Testa distintas esp´cies suportadas pelo compilador gfortran .
e
program t e s t a k i n d g f o r t r a n
i m p l i c i t none
integer , parameter : : i 1= 1 , i 2= 2 , i 4= 4 , i 8= 8 , i 1 6= 16
integer , parameter : : dp= 8 , qp= 10
integer ( kind= i 1 ) : : v i 1
integer ( kind= i 2 ) : : v i 2
integer ( kind= i 4 ) : : v i 4
integer ( kind= i 8 ) : : v i 8
integer ( kind= i 1 6 ) : : v i 1 6
real : : r s i m p l e s
r e a l ( kind= dp ) : : r d u p l a
r e a l ( kind= qp ) : : r quad
complex : : c s i m p l e s
complex ( kind= dp ) : : c d u p l a
complex ( kind= qp ) : : c quad
!
! Mostra maiores numeros r e p r e s e n t a v e i s do t i p o i n t e i r o .
v i 1= huge ( 1 i 1 )
v i 2= huge ( 1 i 2 )
v i 4= huge ( 1 i 4 )
v i 8= huge ( 1 i 8 )
v i 1 6= huge ( 1 i 1 6 )
print * , ’ E s p e c i e s I n t e i r a s : ’
print * , vi1 , vi2 , v i 4
print * , v i 8
print * , v i 1 6
! Mostra maiores numeros r e p r e s e n t a v e i s do t i p o r e a l .
r s i m p l e s= huge ( 1 . 0 )
! Precisao simples
r d u p l a= huge ( 1 . 0 dp ) ! P r e c i s a o d u p l a
r quad= huge ( 1 . 0 qp ) ! P r e c i s a o e s t e n d i d a
!
! C a l c u l a a r a i z quadrada de ( 2 , 2 ) em d i v e r s a s p r e c i s o e s .
c s i m p l e s= s q r t ( ( 2 . 0 , 2 . 0 ) )
c d u p l a=
s q r t ( ( 2 . 0 dp , 2 . 0 dp ) )
c quad=
s q r t ( ( 2 . 0 qp , 2 . 0 qp ) )
!
print * ,
print * , ’ E s p e c i e s R e a i s e Complexas : ’
print * , r s i m p l e s
print * , r d u p l a
print * , r quad
print * , c s i m p l e s
print * , c d u p l a
print * , c quad
!
end program t e s t a k i n d g f o r t r a n
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

29. Cap´
ıtulo 3. Tipos de Vari´veis
a
21
Tabela 3.3: Valores de esp´cies (kind) de tipos de vari´veis suportados pelo compilador F.
e
a
Tipo
Real
Real
Real3
Complex
Complex
Complex
Logical
Logical
Logical
Logical
Integer
Integer
Integer
Integer
Character
N´ mero do Kind
u
(Sequencial)
¨
1
2
3
1
2
3
1
2
3
4
1
2
3
4
1
N´ mero do Kind
u
(Byte)
4
8
16
4
8
16
1
2
4
8
1
2
4
8
1
r d u p l a= s q r t ( 2 . 0 )
! Precis˜o dupla
a
!
! N´ meros c o m p l ex o s : p a r t e r e a l : r a i z de 2 .
u
c s i m p l e s= cmplx ( s q r t ( 2 . 0 ) , s q r t ( 3 . 0 ) )
c d u p l a= cmplx ( s q r t ( 2 . 0 ) , s q r t ( 3 . 0 ) )
!
! Imprime r e s u l t a d o s na t e l a .
print * , r s i m p l e s
print * , r d u p l a
print * , c s i m p l e s
print * , c d u p l a
!
end program t e s t a k i n d F
3.7.2.4
Descri¸˜o
ca
Real precis˜o simples (padr˜o)
a
a
Real precis˜o dupla
a
Real precis˜o qu´drupla
a
a
Complexo precis˜o simples (padr˜o)
a
a
Complexo precis˜o dupla
a
Complexo precis˜o qu´drupla
a
a
L´gico 1 byte
o
L´gico 2 bytes
o
L´gico 4 bytes (padr˜o)
o
a
L´gico 8 bytes
o
Inteiro 1 byte
Inteiro 2 bytes
Inteiro 4 bytes (padr˜o)
a
Inteiro 8 bytes
Caractere, 1 byte por caractere
P ar te i m a g i n a r i a : r a i z de 3 .
´
Literais de diferentes esp´cies
e
Para disting¨ir as esp´cies dos literais (ou constantes) dentre diferentes n´meros fornecidos ao compilador,
u
e
u
utiliza-se o sufixo _<k>, sendo <k> o parˆmetro da esp´cie do tipo:
a
e
Literais inteiros. Constante inteiras, incluindo a esp´cie, s˜o especificadas por:
e
a
[<s>]<nnn...>[_<k>]
onde: <s> ´ um sinal (+ ou −); obrigat´rio se negativo, opcional se positivo. <nnn...> ´ um conjunto
e
o
e
de d´
ıgitos (0 a 9); quaisquer zeros no in´ s˜o ignorados. _<k> ´ um dos parˆmetros de esp´cie do
ıcio a
e
a
e
tipo: 1, 2, 4 ou 8; esta op¸˜o explicita a esp´cie do tipo ` qual o literal pertence.
ca
e
a
Literais reais. Constantes reais s˜o especificadas de diferentes maneiras, dependendo se possuem ou n˜o
a
a
parte exponencial. A regra b´sica para a especifica¸˜o de um literal real j´ foi definida na se¸˜o 3.3.
a
ca
a
ca
Para explicitar a esp´cie do tipo real ` qual o literal pertence, deve-se incluir o sufixo _<k>, onde <k>
e
a
´ um dos parˆmetros de esp´cie do tipo: 4, 8 ou 16. Por exemplo:
e
a
e
2.0_8: para indicar tipo real, esp´cie 8.
e
Literais complexos. A regra b´sica para a especifica¸˜o de um literal complexo j´ foi definida na se¸˜o
a
ca
a
ca
3.4. Para explicitar a esp´cie do tipo ` qual o literal pertence, deve-se incluir o sufixo _<k>, onde <k>
e
a
´ um dos parˆmetros de esp´cie do tipo: 4, 8 ou 16, em cada uma das partes real e imagin´ria do
e
a
e
a
literal complexo. Por exemplo:
(1.0_8,3.5345_8): para indicar tipo complexo, esp´cie 8.
e
Literais l´gicos. Uma constante l´gica pode tomar uma das seguintes formas:
o
o
.TRUE.[_<k>]
3 Vari´veis
a
reais e complexas de precis˜o qu´drupla n˜o s˜o suportadas por todas as vers˜es do compilador F.
a
a
a a
o
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

30. 22
3.7. O conceito de esp´cie (kind)
e
.FALSE.[_<k>]
onde <k> ´ um dos parˆmetros de esp´cie do tipo: 1, 2, 4 ou 8.
e
a
e
3.7.3
Fun¸˜es intr´
co
ınsecas associadas ` esp´cie
a
e
Embora as declara¸˜es de esp´cie do tipo possam variar para diferentes compiladores, o padr˜o da
co
e
a
linguagem estabelece um conjunto de fun¸˜es intr´
co
ınsecas que facilitam a determina¸˜o e a declara¸˜o destas
ca
ca
esp´cies de uma forma totalmente port´vel, isto ´, independente de compilador e/ou arquitetura.
e
a
e
As fun¸˜es intr´
co
ınsecas descritas nesta e nas subsequentes se¸˜es ser˜o novamente abordadas no cap´
co
a
ıtulo
7, onde ser˜o apresentadas todas as rotinas intr´
a
ınsecas fornecidas pelo padr˜o da linguagem Fortran 95.
a
3.7.3.1
KIND(X)
A fun¸˜o intr´
ca
ınseca KIND(X), a qual tem como argumento uma vari´vel ou constante de qualquer tipo
a
intr´
ınseco, retorna o valor inteiro que identifica a esp´cie da vari´vel X. Por exemplo,
e
a
program t e s f u n k i n d
i m p l i c i t none
integer : : i , j
integer , parameter : : dp= 2
real : : y
r e a l ( kind= dp ) : : x
!
i= kind ( x ) ! i= 2
j= kind ( y ) ! Depende do s i s t e m a ( j =1 para c o m p i l a d o r F ) .
print * , i
print * , j
end program t e s f u n k i n d
Outros exemplos:
KIND(0)
KIND(0.0)
KIND(.FALSE.)
KIND(’A’)
KIND(0.0D0)
3.7.3.2
!
!
!
!
!
!
!
!
!
!
Retorna a esp´cie padr~o do tipo inteiro.
e
a
(Dependente do processador).
Retorna a esp´cie padr~o do tipo real.
e
a
(Depende do processador).
Retorna a esp´cie padr~o do tipo l´gico.
e
a
o
(Depende do processador).
Fornece a esp´cie padr~o de caractere.
e
a
(Sempre igual a 1).
Usualmente retorna a esp´cie do tipo real de precis~o dupla.
e
a
(Pode n~o ser aceito por todos compiladores).
a
SELECTED_REAL_KIND(P,R)
A fun¸˜o intr´
ca
ınseca SELECTED_REAL_KIND(P,R) tem dois argumentos opcionais: P e R. A vari´vel P
a
especifica a precis˜o (n´mero de d´
a
u
ıgitos decimais) m´
ınima requerida e R especifica o intervalo de varia¸˜o
ca
m´
ınimo da parte exponencial da vari´vel.
a
A fun¸˜o SELECTED_REAL_KIND(P,R) retorna o valor da esp´cie que satisfaz, ou excede minimamente, os
ca
e
requerimentos especificados por P e R. Se mais de uma esp´cie satisfaz estes requerimentos, o valor retornado
e
´ aquele com a menor precis˜o decimal. Se a precis˜o requerida n˜o for dispon´
e
a
a
a
ıvel, a fun¸˜o retorna o valor
ca
-1; se o intervalo da exponencial n˜o for dispon´
a
ıvel, a fun¸˜o retorna -2 e se nenhum dos requerimentos for
ca
dispon´
ıvel, o valor -3 ´ retornado.
e
Esta fun¸˜o, usada em conjunto com a declara¸˜o de esp´cie, garante uma completa portabilidade ao
ca
ca
e
programa, desde que o processador tenha dispon´
ıveis os recursos solicitados. O exemplo a seguir ilustra o
uso desta fun¸˜o intr´
ca
ınseca e outros recursos.
program t e s s e l e c t e d
integer , parameter : : i 1 0= s e l e c t e d r e a l k i n d ( 1 0 , 2 0 0 )
integer , parameter : : dp= 8
r e a l ( kind= i 1 0 ) : : a , b , c
r e a l ( kind= dp ) : : d
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

31. Cap´
ıtulo 3. Tipos de Vari´veis
a
23
print * , i 1 0
a= 2 . 0 i 1 0
b= s q r t ( 5 . 0 i 1 0 )
c= 3 . 0 e 1 0 i 1 0 ,
d= 1 . 0 e201 dp
print * , a
print * , b
print * , c
print * , d
end program t e s s e l e c t e d
Pode-se ver que a precis˜o requerida na vari´vel I10 ´ dispon´ na esp´cie correspondente ` precis˜o dupla
a
a
e
ıvel
e
a
a
de uma vari´vel real para os compiladores mencionados (ver, por exemplo, tabela 3.2). Um outro recurso
a
dispon´ ´ a possibilidade de especificar constantes de uma determinada esp´cie, como na atribui¸˜o
ıvel e
e
ca
A= 2.0_I10
A constante A foi explicitamente especificada como pertencente ` esp´cie I10 seguindo-se o valor num´rico
a
e
e
com um underscore e com o parˆmetro de esp´cie do tipo (I10). Deve-se notar tamb´m que a defini¸˜o da
a
e
e
ca
esp´cie I10, seguida da declara¸˜o das vari´veis A, B e C como sendo desta esp´cie, determina o intervalo
e
ca
a
e
m´
ınimo de varia¸˜o da parte exponencial destas vari´veis. Se o parˆmetro da esp´cie associada ` constante
ca
a
a
e
a
I10 for distinto do parˆmetro DP, a vari´vel D n˜o poderia ter sido declarada tamb´m da esp´cie I10, pois
a
a
a
e
e
a atribui¸˜o
ca
D= 1.0E201_I10
iria gerar uma mensagem de erro no momento da compila¸˜o, uma vez que a parte exponencial excede
ca
o intervalo definido para a esp´cie I10 (200). Contudo, para alguns compiladores, como o gfortran, a
e
compila¸˜o ir´ resultar em I10 = DP, tornando desnecess´ria uma das declara¸˜es acima. Este exemplo
ca
a
a
co
demonstra a flexibilidade e a portabilidade propiciada pelo uso da fun¸˜o intr´
ca
ınseca SELECTED_REAL_KIND.
3.7.3.3
SELECTED_INT_KIND(R)
A fun¸˜o intr´
ca
ınseca SELECTED_INT_KIND(R) ´ usada de maneira similar ` fun¸˜o SELECTED_REAL_KIND.
e
a
ca
Agora, a fun¸˜o tem um unico argumento R, o qual especifica o intervalo de n´meros inteiros requerido.
ca
´
u
Assim, SELECTED_INT_KIND(r) retorna o valor da esp´cie que representa, no m´
e
ınimo, valores inteiros no
intervalo −10r a +10r . Se mais de uma esp´cie satisfaz o requerimento, o valor retornado ´ aquele com o
e
e
menor intervalo no expoente r. Se o intervalo n˜o for dispon´
a
ıvel, o valor -1 ´ retornado.
e
O exemplo a seguir mostra a declara¸ao de um inteiro de uma maneira independente do sistema:
c˜
INTEGER, PARAMETER :: I8= SELECTED_INT_KIND(8)
INTEGER(KIND= I8) :: IA, IB, IC
As vari´veis inteiras IA, IB e IC podem ter valores entre −108 a +108 no m´
a
ınimo, se dispon´
ıvel pelo
processador.
3.8
Tipos derivados
Uma das maiores vantagens do Fortran 90/95 sobre seus antecessores est´ na disponibilidade ao proa
gramador de definir seus pr´prios tipos de vari´veis. Estas s˜o os chamados tipos derivados, tamb´m
o
a
a
e
freq¨entemente denominados de estruturas.
u
A forma geral da declara¸˜o de um tipo derivado ´:
ca
e
TYPE [[,<acesso> ] ::] <nome do tipo >
[PRIVATE]
<declara¸~es de componentes >
co
END TYPE [<nome do tipo >]
onde cada <declara¸˜o de componentes> tem a forma
ca
<tipo >[[, <atributos >] ::] <lista de componentes >
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

32. 24
3.8. Tipos derivados
onde aqui o <tipo> pode ser um tipo de vari´vel intr´
a
ınseca ou outro tipo derivado. A declara¸˜o de uma
ca
lista de vari´veis do tipo derivado <nome do tipo> ´ feita atrav´s da linha:
a
e
e
TYPE (<nome do tipo >) [::] <lista de nomes>
Para tentar-se entender o uso de uma vari´vel de tipo derivado, vamos definir um novo tipo: PONTO, o qual
a
ser´ constru´ a partir de trˆs valores reais, representando os valores das coordenadas x, y e z do ponto no
a
ıdo
e
espa¸o cartesiano:
c
program d e f t i p o d e r
i m p l i c i t none
type : : ponto
real : : x , y , z
end type ponto
!
type ( ponto ) : : c e n t r o , a p i c e
!
a p i c e%x= 0 . 0
a p i c e%y= 1 . 0
a p i c e%z= 0 . 0
c e n t r o = ponto ( 0 . 0 , 0 . 0 , 0 . 0 )
!
print * , a p i c e
print * , c e n t r o
!
end program d e f t i p o d e r
No exemplo acima, definiu-se o tipo derivado PONTO, composto por trˆs componentes reais x, y e z. Em
e
seguida, declarou-se duas vari´veis como sendo do tipo PONTO: CENTRO e APICE. A seguir, atribuiu-se os
a
valores para estas vari´veis. Finalmente, mandou-se imprimir na tela o valor das vari´veis.
a
a
Como foi mostrado na atribui¸˜o APICE%X= 0.0, cada componente da vari´vel de tipo derivado pode ser
ca
a
referenciada individualmente por meio do caractere seletor de componente, “%”. J´ a vari´vel CENTRO teve
a
a
os valores de suas componentes definidos pelo construtor de estrutura:
CENTRO= PONTO(0.0,0.0,0.0)
ou seja, CENTRO%X= 0.0, CENTRO%Y= 0.0 e CENTRO%Z= 0.0.
Estruturas definidas desta forma podem ser interessantes quando o programador quer classificar determinados objetos caracterizados por parˆmetros e/ou qualificadores representados por vari´veis de diferentes
a
a
´
tipos. E poss´
ıvel construirem-se estruturas progressivamente mais complicadas definindo-se novos tipos
derivados que englobam aqueles previamente definidos. Por exemplo,
TYPE :: RETA
TYPE (PONTO) :: P1,P2
END TYPE RETA
TYPE (RETA) :: DIAGONAL_PRINCIPAL
!
DIAGONAL_PRINCIPAL%P1%X= 0.0
DIAGONAL_PRINCIPAL%P1%Y= 0.0
DIAGONAL_PRINCIPAL%P1%Z= 0.0
!
DIAGONAL_PRINCIPAL%P2= PONTO(1.0,1.0,1.0)
Aqui foi definido o tipo RETA no espa¸o cartesiano, a qual ´ totalmente caracterizada por dois pontos, P1 e P2,
c
e
os quais, por sua vez s˜o ternas de n´meros do tipo (x, y, z). Definiu-se ent˜o a vari´vel DIAGONAL_PRINCIPAL
a
u
a
a
como sendo do tipo RETA e definiu-se os valores dos dois pontos no espa¸o P1 e P2 que caracterizam a diagonal
c
principal. Note o uso de dois seletores de componente para definir o valor da coordenada x do ponto P1
da DIAGONAL_PRINCIPAL. Note, por outro lado, o uso do construtor de estrutura para definir a posi¸˜o do
ca
ponto P2, como componente da diagonal principal.
O exemplo a seguir, define o tipo ALUNO, caracterizado por NOME, CODIGO de matr´
ıcula, notas parciais
N1, N2 e N3 e m´dia final MF. O programa lˆ as notas e calcula e imprime a m´dia final do aluno.
e
e
e
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

33. Cap´
ıtulo 3. Tipos de Vari´veis
a
25
! Dados a c e r c a de a l u n o s usando t i p o d e r i v a d o .
program a l u n o s
i m p l i c i t none
type : : a l u n o
character ( len= 2 0 ) : : nome
integer : : c o d i g o
r e a l : : n1 , n2 , n3 , mf
end type a l u n o
type ( a l u n o ) : : d i s c e n t e
!
print * , ’Nome : ’
read ’ ( a ) ’ , d i s c e n t e%nome
print * , ’ c o d i g o : ’
read * , d i s c e n t e%c o d i g o
print * , ’ Notas : N1 , N2 , N3 : ’
read * , d i s c e n t e%n1 , d i s c e n t e%n2 , d i s c e n t e%n3
d i s c e n t e%mf= ( d i s c e n t e%n1 + d i s c e n t e%n2 + d i s c e n t e%n3 ) / 3 . 0
print * , ’ ’
print *,’−−−−−−−−−−−> ’ , d i s c e n t e%nome , ’ ( ’ , d i s c e n t e%c o d i g o , ’ ) <−−−−−−−−−−−’
print * , ’
Media f i n a l : ’ , d i s c e n t e%mf
end program a l u n o s
Em Fortran 95, tornou-se poss´
ıvel inicializar os valores dos componentes dos tipos derivados. O valor
deve ser especificado quando o componente ´ declarado como parte da defini¸˜o do tipo. Se o componente
e
ca
n˜o for um ponteiro, a inicializa¸˜o ´ feita de forma usual, com um sinal de igual seguido da express˜o de
a
ca e
a
inicializa¸˜o. Se o componente for um ponteiro, a unica inicializa¸˜o admitida ´ o s´
ca
´
ca
e
ımbolo de atribui¸˜o de
ca
um ponteiro (=>), seguida pela fun¸˜o intr´
ca
ınseca NULL() (se¸˜o 7.16). Em ambos os casos os caracteres ::
ca
s˜o exigidos.
a
Uma inicializa¸˜o n˜o deve necessariamente se aplicar a todos os componentes de um tipo derivado. Um
ca a
exemplo v´lido seria:
a
TYPE :: ENTRY
REAL
:: VALOR= 2.0
INTEGER
INDEX
TYPE(ENTRY), POINTER :: NEXT => NULL()
END TYPE ENTRY
Dada uma declara¸˜o de matriz tal como
ca
TYPE(ENTRY), DIMENSION(100) :: MATRIZ
os sub-objetos tais como MATRIZ(3)%VALOR ter˜o automaticamente o valor 2.0 e a seguinte opera¸˜o, que
a
ca
usa uma fun¸˜o intr´
ca
ınseca ASSOCIATED(MATRIX(3)%NEXT) vai retornar o valor .FALSE. (ver se¸˜o 7.3).
ca
Se as declara¸˜es de tipos derivados estiverem aninhadas, as inicializa¸˜es associadas a componentes s˜o
co
co
a
reconhecidas em todos os n´
ıveis. Assim,
TYPE :: NODO
INTEGER
CONTA
TYPE(ENTRY) ELEMENTO
END TYPE NODO
TYPE(NODO) N
ocasiona que o componente N%ELEMENTO%VALOR ter´ automaticamente o valor 2.0.
a
Os componentes do tipo derivado continuam podendo ser inicializados em declara¸˜es de vari´veis do
co
a
tipo, tais como
TYPE(ENTRY), DIMENSION(100) :: MATRIZ= ENTRY(HUGE(0.0), HUGE(0), NULL())
em cuja situa¸˜o a inicializa¸˜o inicial ´ ignorada.
ca
ca
e
Autor: Rudi Gaelzer – IFM/UFPel
Impresso: 12 de abril de 2010

34. 26
Autor: Rudi Gaelzer – IFM/UFPel
3.8. Tipos derivados
Impresso: 12 de abril de 2010

35. Cap´
ıtulo 4
Express˜es e Atribui¸˜es Escalares
o
co
Em uma express˜o, o programa descreve as opera¸˜es que devem ser executadas pelo computador. O
a
co
resultado desta express˜o pode ent˜o ser atribu´ a uma vari´vel. H´ diferentes conjuntos de regras para
a
a
ıdo
a
a
express˜es e atribui¸˜es, dependendo se as vari´veis em quest˜o s˜o num´ricas, l´gicas, caracteres ou de tipo
o
co
a
a a
e
o
derivado; e tamb´m se as express˜es s˜o escalares ou matriciais.
e
o
a
Cada um dos conjunto de regras para express˜es escalares ser´ agora discutido.
o
a
4.1
Regras b´sicas
a
Uma express˜o em Fortran 90/95 ´ formada de operandos e operadores, combinados de tal forma que
a
e
estes seguem as regras de sintaxe. Os operandos podem ser constantes, vari´veis ou fun¸˜es e uma express˜o,
a
co
a
por si mesma, tamb´m pode ser usada como operando.
e
Uma express˜o simples envolvendo um operador unit´rio ou mon´dico tem a seguinte forma:
a
a
a
operador operando
um exemplo sendo
-Y
J´ uma express˜o simples envolvendo um operador bin´rio (ou di´dico) tem a forma:
a
a
a
a
operando operador operando
um exemplo sendo
X + Y
Uma express˜o mais complicada seria
a
operando operador operando operador operando
onde operandos consecutivos s˜o separados por um unico operador. Cada operando deve ter valor definido e
a
´
o resultados da express˜o deve ser matematicamente definido; por exemplo, divis˜o por zero n˜o ´ permitido.
a
a
a e
A sintaxe do Fortran estabelece que as partes de express˜es sem parˆnteses sejam desenvolvidas da
o
e
esquerda para a direita para operadores de igual precedˆncia, com a exce¸˜o do operador “**” (ver se¸˜o
e
ca
ca
4.2). Caso seja necess´rio desenvolver parte de uma express˜o, ou sub-express˜o, antes de outra, parˆnteses
a
a
a
e
podem ser usados para indicar qual sub-express˜o deve ser desenvolvida primeiramente. Na express˜o
a
a
operando operador (operando operador operando)
a sub-express˜o entre parˆnteses ser´ desenvolvida primeiro e o resultado usado como um operando para o
a
e
a
primeiro operador, quando ent˜o a express˜o completa ser´ desenvolvida usando a norma padr˜o, ou seja,
a
a
a
a
da esquerda para a direita.
Se uma express˜o ou sub-express˜o n˜o ´ contida entre parˆnteses, ´ permitido ao processador desenvolver
a
a a e
e
e
uma express˜o equivalente, a qual ´ uma express˜o que resultar´ no mesmo valor, exceto por erros de
a
e
a
a
arredondamento num´rico. As duas opera¸˜es a seguir s˜o, em princ´
e
co
a
ıpio, equivalentes:
27