Fortran

Introdu c ao ao Fortran 90/95
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 atica, Funda c ao Universidade Federal de Pelotas, Pelotas - RS.
In cio: Janeiro de 2005.
Vers ao: 12 de abril de 2010
Sum ario
Refer encias Bibliogr acas 1 Introdu c ao 1.1 As origens da Linguagem Fortran . . . . . . . . . . 1.2 O padr ao Fortran 90 . . . . . . . . . . . . . . . . . 1.2.1 Recursos novos do Fortran 90 . . . . . . . . 1.2.2 Recursos em obsolesc encia do Fortran 90 . 1.2.3 Recursos removidos do Fortran 90 . . . . . 1.3 Uma revis ao menor: Fortran 95 . . . . . . . . . . . 1.3.1 Recursos novos do Fortran 95 . . . . . . . . 1.3.2 Recursos em obsolesc encia do Fortran 95 . 1.3.3 Recursos removidos do Fortran 95 . . . . . 1.4 O Fortran no S eculo XXI: Fortran 2003 . . . . . . 1.4.1 Recursos novos do Fortran 2003 . . . . . . . 1.4.2 Recursos em obsolesc encia do Fortran 2003 1.4.3 Recursos removidos do Fortran 2003 . . . . 1.5 O novo padr ao: Fortran 2008 . . . . . . . . . . . . 1.5.1 Recursos novos do Fortran 2008 . . . . . . . 1.6 Coment arios sobre a bibliograa . . . . . . . . . . 1.7 Observa c oes sobre a apostila e agradecimentos . . 2 Formato do C odigo-Fonte 2.1 Formato do programa-fonte . . 2.2 Nomes em Fortran 90/95 . . . 2.3 Entrada e sa da padr oes . . . . 2.4 Conjunto de caracteres aceitos v 1 1 2 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
9 . 9 . 11 . 11 . 12 13 13 14 14 15 15 16 17 17 17 17 19 19 21 22 22 22 23 23
3 Tipos de Vari aveis 3.1 Declara c ao de tipo de vari avel . . . . . . . . . . 3.2 Vari aveis do tipo INTEGER . . . . . . . . . . . . 3.3 Vari aveis do tipo REAL . . . . . . . . . . . . . . 3.4 Vari aveis do tipo COMPLEX . . . . . . . . . . . . 3.5 Vari aveis do tipo CHARACTER . . . . . . . . . . . 3.6 Vari aveis do tipo LOGICAL . . . . . . . . . . . . 3.7 O conceito de esp ecie (kind) . . . . . . . . . . . 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 ecies . 3.7.3 Fun c oes intr nsecas associadas ` a esp ecie 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
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
ii
SUMARIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 27 28 29 30 30 32 35 35 35 36 36 36 36 37 37 38 38 39 41 41 42 42 45 45 49 51 52 52 52 53 53 55 56 56 57 57 57 58 59 62 62 62 65 65 65 66 66 66 67 67 68 68 69 69 69 69
4 Express oes e Atribui c oes Escalares 4.1 Regras b asicas . . . . . . . . . . . . . . . . . . 4.2 Express oes num ericas escalares . . . . . . . . . 4.3 Atribui c oes num ericas escalares . . . . . . . . . 4.4 Operadores relacionais . . . . . . . . . . . . . . 4.5 Express oes e atribui c oes l ogicas escalares . . . . 4.6 Express oes e atribui c oes de caracteres escalares 5 Comandos e Construtos de Controle de Fluxo 5.1 Comandos obsoletos do Fortran 77 . . . . . . . 5.1.1 R otulos (statement labels) . . . . . . . . 5.1.2 Comando GO TO incondicional . . . . . . 5.1.3 Comando GO TO computado . . . . . . . 5.1.4 Comando IF aritm etico . . . . . . . . . 5.1.5 Comandos ASSIGN e GO TO atribu do . . 5.1.6 La cos DO rotulados . . . . . . . . . . . . 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 c ao EXIT . . . . . . . . . . . . . . 5.3.3 Instru c ao CYCLE . . . . . . . . . . . . . 5.4 Construto CASE . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
6 Processamento de Matrizes 6.1 Terminologia e especica c oes de matrizes . . . . . 6.2 Express oes e atribui c oes envolvendo matrizes . . . 6.3 Se c oes de matrizes . . . . . . . . . . . . . . . . . . 6.3.1 Subscritos simples . . . . . . . . . . . . . . 6.3.2 Tripleto de subscritos . . . . . . . . . . . . 6.3.3 Vetores de subscritos . . . . . . . . . . . . . 6.4 Atribui c oes de matrizes e sub-matrizes . . . . . . . 6.5 Matrizes de tamanho zero . . . . . . . . . . . . . . 6.6 Construtores de matrizes . . . . . . . . . . . . . . . 6.6.1 A fun c ao intr nseca RESHAPE. . . . . . . . . 6.6.2 A ordem dos elementos de matrizes . . . . . 6.7 Rotinas intr nsecas elementais aplic aveis a matrizes 6.8 Comando e construto WHERE . . . . . . . . . . . . . 6.8.1 Comando WHERE . . . . . . . . . . . . . . . 6.8.2 Construto WHERE . . . . . . . . . . . . . . . 6.9 Matrizes aloc aveis . . . . . . . . . . . . . . . . . . 6.10 Comando e construto FORALL . . . . . . . . . . . . 6.10.1 Comando FORALL . . . . . . . . . . . . . . . 6.10.2 Construto FORALL . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
7 Rotinas Intr nsecas 7.1 Categorias de rotinas intr nsecas . . . . . . . . . . . . . 7.2 Declara c ao e atributo INTRINSIC . . . . . . . . . . . . . 7.3 Fun c oes inquisidoras de qualquer tipo . . . . . . . . . . 7.4 Fun c oes elementais num ericas . . . . . . . . . . . . . . . 7.4.1 Fun c oes elementais que podem converter . . . . . 7.4.2 Fun c oes elementais que n ao convertem . . . . . . 7.5 Fun c oes elementais matem aticas . . . . . . . . . . . . . 7.6 Fun c oes elementais l ogicas e de caracteres . . . . . . . . 7.6.1 Convers oes caractere-inteiro . . . . . . . . . . . . 7.6.2 Fun c oes de compara c ao l exica . . . . . . . . . . . 7.6.3 Fun c oes elementais para manipula c oes de strings 7.6.4 Convers ao l ogica . . . . . . . . . . . . . . . . . . 7.7 Fun c oes n ao-elementais para manipula c ao de strings . .
Autor: Rudi Gaelzer IFM/UFPel
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
Impresso: 12 de abril de 2010
SUMARIO 7.7.1 Fun c ao inquisidora para manipula c ao de strings . . . . . 7.7.2 Fun c oes transformacionais para manipula c ao de strings Fun c oes inquisidoras e de manipula c oes num ericas . . . . . . . 7.8.1 Modelos para dados inteiros e reais . . . . . . . . . . . . 7.8.2 Fun c oes num ericas inquisidoras . . . . . . . . . . . . . . 7.8.3 Fun c oes elementais que manipulam quantidades reais . . 7.8.4 Fun c oes transformacionais para valores de esp ecie (kind) Rotinas de manipula c ao de bits . . . . . . . . . . . . . . . . . . 7.9.1 Fun c ao inquisidora . . . . . . . . . . . . . . . . . . . . . 7.9.2 Fun c oes elementais . . . . . . . . . . . . . . . . . . . . . 7.9.3 Subrotina elemental . . . . . . . . . . . . . . . . . . . . Fun c ao de transfer encia . . . . . . . . . . . . . . . . . . . . . . Fun c oes de multiplica c ao vetorial ou matricial . . . . . . . . . . Fun c oes transformacionais que reduzem matrizes . . . . . . . . 7.12.1 Caso de argumento u nico . . . . . . . . . . . . . . . . . 7.12.2 Argumento opcional DIM . . . . . . . . . . . . . . . . . . 7.12.3 Argumento opcional MASK . . . . . . . . . . . . . . . . . Fun c oes inquisidoras de matrizes . . . . . . . . . . . . . . . . . 7.13.1 Status de aloca c ao . . . . . . . . . . . . . . . . . . . . . 7.13.2 Limites, forma e tamanho . . . . . . . . . . . . . . . . . Fun c oes de constru c ao e manipula c ao de matrizes . . . . . . . . 7.14.1 Fun c ao elemental MERGE . . . . . . . . . . . . . . . . . . 7.14.2 Agrupando e desagrupando matrizes . . . . . . . . . . . 7.14.3 Alterando a forma de uma matriz . . . . . . . . . . . . 7.14.4 Fun c ao transformacional para duplica c ao . . . . . . . . 7.14.5 Fun c oes de deslocamento matricial . . . . . . . . . . . . 7.14.6 Transposta de uma matriz . . . . . . . . . . . . . . . . . Fun c oes transformacionais para localiza c ao geom etrica . . . . . Fun c ao transformacional para dissocia c ao de ponteiro . . . . . Subrotinas intr nsecas n ao-elementais . . . . . . . . . . . . . . . 7.17.1 Rel ogio de tempo real . . . . . . . . . . . . . . . . . . . 7.17.2 Tempo da CPU . . . . . . . . . . . . . . . . . . . . . . . 7.17.3 N umeros aleat orios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iii 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
7.8
7.9
7.10 7.11 7.12
7.13
7.14
7.15 7.16 7.17
8 Sub-Programas e M odulos 8.1 Unidades de programa . . . . . . . . . . . . . . . . . . . . . . 8.1.1 Programa principal . . . . . . . . . . . . . . . . . . . . 8.1.2 Rotinas externas . . . . . . . . . . . . . . . . . . . . . 8.1.3 M odulos . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2 Sub-programas . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2.1 Fun c oes e subrotinas . . . . . . . . . . . . . . . . . . . 8.2.2 Rotinas internas . . . . . . . . . . . . . . . . . . . . . 8.2.3 Argumentos de sub-programas . . . . . . . . . . . . . 8.2.4 Comando RETURN . . . . . . . . . . . . . . . . . . . . . 8.2.5 Atributo e declara c ao INTENT . . . . . . . . . . . . . . 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 c oes de valor matricial . . . . . . . . . . . . . . . . 8.2.14 Recursividade e rotinas recursivas . . . . . . . . . . . 8.2.15 Atributo e declara c ao SAVE . . . . . . . . . . . . . . . 8.2.16 Fun c oes de efeito lateral e rotinas puras . . . . . . . . 8.2.17 Rotinas elementais . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . .
iv 8.3
SUMARIO M odulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.1 Dados globais . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.3.2 Rotinas de m odulos . . . . . . . . . . . . . . . . . . . . . . . . 8.3.3 Atributos e declara c oes PUBLIC e PRIVATE . . . . . . . . . . . . 8.3.4 Interfaces e rotinas gen ericas . . . . . . . . . . . . . . . . . . . 8.3.5 Estendendo rotinas intr nsecas via blocos de interface gen ericos Ambito (Scope) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.1 Ambito dos r otulos . . . . . . . . . . . . . . . . . . . . . . . . . 8.4.2 Ambito dos nomes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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
8.4
9 Comandos de Entrada/Sa da de Dados 9.1 Comandos de Entrada/Sa da: introdu c ao r apida 9.2 Declara c ao NAMELIST . . . . . . . . . . . . . . . . 9.3 Unidades l ogicas . . . . . . . . . . . . . . . . . . 9.4 Comando OPEN . . . . . . . . . . . . . . . . . . . 9.5 Comando READ . . . . . . . . . . . . . . . . . . . 9.6 Comandos PRINT e WRITE . . . . . . . . . . . . . 9.7 Comando FORMAT e especicador FMT= . . . . . . 9.8 Descritores de edi c ao . . . . . . . . . . . . . . . . 9.8.1 Contadores de repeti c ao . . . . . . . . . . 9.8.2 Descritores de edi c ao de dados . . . . . . 9.8.3 Descritores de controle de edi c ao . . . . . 9.8.4 Descritores de edi c ao de strings . . . . . . 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 . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . .
Refer encias Bibliogr acas

[1] Intel Fortran Compiler for Linux. http://www.intel.com/software/products/compilers/in/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 c ao. [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 Programers Guide to Fortran77. prof77.pdf, Leicester, 2001. Acesso em: 01 jun. 2005. http://www.star.le.ac.uk/ cgp/G. S., BRO77 Programmers. Acesso em: 01 em:
[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.
[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.
vi
REFERENCIAS BIBLIOGRAFICAS
Cap tulo 1
Introdu c ao
I dont know what the technical characteristics of the standard language for scientic 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 c ao Fortran 95.
1.1
As origens da Linguagem Fortran
Programa c ao no per odo inicial do uso de computadores para a solu c ao de problemas em f sica, qu mica, engenharia, matem atica e outras areas da ci encia era um processo complexo e tedioso ao extremo. Programadores necessitavam de um conhecimento detalhado das instru c oes, registradores, endere cos de mem oria e outros constituintes da Unidade Central de Processamento (CPU1 ) do computador para o qual eles escreviam o c odigo. O C odigo-Fonte era escrito em um nota c ao num erica denominada c odigo octal. Com o tempo, c odigos mnem onicos foram introduzidos, uma forma de programa c ao conhecida como c odigo num erico ou c odigo Assembler. Estes c odigos eram traduzidos em instru c oes para a CPU por programas conhecidos como Assemblers. Durante os anos 50 cou claro que esta forma de programa c ao era de todo inconveniente, no m nimo, devido ao tempo necess ario para se escrever e testar um programa, embora esta forma de programa c ao possibilitasse um uso otimizado dos recursos da CPU. Estas diculdades motivaram que um time de programadores da IBM, liderados por John Backus, desenvolvessem uma das primeiras chamadas linguagem de alto-n vel, denominada FORTRAN (signicando FORmula TRANslation). Seu objetivo era produzir uma linguagem que fosse simples de ser entendida e usada, mas que gerasse um c odigo num erico quase t ao eciente quanto a linguagem Assembler. Desde o in cio, o Fortran era t ao simples de ser usado que era poss vel programar f ormulas matem aticas quase como se estas fossem escritas de forma simb olica. Isto permitiu que programas fossem escritos mais rapidamente que antes, com somente uma pequena perda de eci encia no processamento, uma vez que todo cuidado era dedicado na constru c ao do compilador, isto e, no programa que se encarrega de traduzir o c odigo-fonte em Fortran para c odigo Assembler ou octal. Mas o Fortran foi um passo revolucion ario tamb em porque o programadores foram aliviados da tarefa tediosa de usar Assembler, assim concentrando-se mais na solu c ao do problema em quest ao. Mais importante ainda, computadores se tornaram acess veis a qualquer cientista ou engenheiro disposto a devotar um pequeno esfor co na aquisi c ao de um conhecimento b asico em Fortran; a tarefa da programa c ao n ao estava mais restrita a um corpus pequeno de programadores especialistas. O Fortran disseminou-se rapidamente, principalmente nas areas da f sica, engenharia e matem atica, 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 os quatro anos de trabalho, a Associa c ao Americana de Padr oes (American Standards Association ), posteriormente Instituto Americano Nacional de Padr oes (American National Standards Institute, ou ANSI) originou o primeiro padr ao para uma linguagem de programa c ao, agora conhecido como Fortran 66. Essencialmente, era uma subconjunto comum de v arios dialetos, de tal forma que cada dialeto poderia ser reconhecido como uma extens ao do padr ao. Aqueles usu arios que desejavam escrever programas port aveis deveriam evitar as extens oes e restringir-se ao padr ao.
1 Do
ingl es: Central Processing Unit.
1.2. O padr ao Fortran 90
O Fortran trouxe consigo v arios outros avan cos, al em de sua facilidade de aprendizagem combinada com um enfoque em execu c ao eciente de c odigo. Era, por exemplo, uma linguagem que permanecia pr oxima (e explorava) o hardware dispon vel, ao inv es de ser um conjunto de conceitos abstratos. Ela tamb em introduziu, atrav es das declara c oes COMMON e EQUIVALENCE, a possibilidade dos programadores controlarem a aloca c ao da armazenagem de dados de uma forma simples, um recurso que era necess ario nos prim ordios da computa c ao, quando havia pouco espa co de mem oria, mesmo que estas declara c oes sejam agora consideradas potencialmente perigosas e o seu uso desencorajado. Finalmente, o c odigo fonte permitia espa cos em branco na sua sintaxe, liberando o programador da tarefa de escrever c odigo em colunas rigidamente denidas e permitindo que o corpo do programa fosse escrito da forma desejada e visualmente mais atrativa. A prolifera c ao de dialetos permaneceu um problema mesmo ap os a publica c ao do padr ao Fortran 66. A primeira diculdade foi que muitos compiladores n ao aderiram ao padr ao. A segunda foi a implementa c ao, em diversos compiladores, de recursos que eram essenciais para programas de grande escala, mas que eram ignorados pelo padr ao. Diferentes compiladores implementavam estes recursos de formas distintas. Esta situa c ao, combinada com a exist encia de falhas evidentes na linguagem, tais como a falta de constru c oes estruturadas de programa c ao, resultaram na introdu c ao de um grande n umero de pr e-processadores. Estes eram programas que eram capazes de ler o c odigo fonte de algum dialeto bem denido de Fortran e gerar um segundo arquivo com o texto no padr ao, o qual ent ao era apresentado ao compilador nesta forma. 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 e-processador fossem port aveis, podendo ser compilados em diferentes computadores, o c odigo gerado era muitas vezes de uma diculdade proibitiva para a leitura direta. Estas diculdades foram parcialmente removidas pela publica c ao de um novo padr ao, em 1978, conhecido como Fortran 77. Ele inclu a diversos novos recursos que eram baseados em extens oes comerciais ou pr eprocessadores e era, portanto, n ao um subconjunto comum de dialetos existentes, mas sim um novo dialeto por si s o. O per odo de transi c ao entre o Fortran 66 e o Fortran 77 foi muito mais longo que deveria, devido aos atrasos na elabora c ao de novas vers oes dos compiladores e os dois padr oes coexistiram durante um intervalo de tempo consider avel, que se estendeu at e meados da d ecada de 80. Eventualmente, os fabricantes de compiladores passaram a liber a-los somente com o novo padr ao, o que n ao impediu o uso de programas escritos em Fortran 66, uma vez que o Fortran 77 permitia este c odigo antigo por compatibilidade. Contudo, diversas extens oes n ao foram mais permitidas, uma vez que o padr ao n ao as incluiu na sua sintaxe.
1.2
O padr ao Fortran 90
Ap os trinta anos de exist encia, Fortran n ao mais era a u nica linguagem de programa c ao dispon vel para os programadores. Ao longo do tempo, novas linguagens foram desenvolvidas e, onde elas se mostraram mais adequadas para um tipo particular de aplica c ao, foram adotadas em seu lugar. A superioridade do Fortran sempre esteve na area de aplica c oes num ericas, cient cas, t ecnicas e de engenharia. A comunidade de usu arios do Fortran realizou um investimento gigantesco em c odigos, com muitos programas em uso freq uente, alguns com centenas de milhares ou milh oes de linhas de c odigo. Isto n ao signicava, contudo, que a comunidade estivesse completamente satisfeita com a linguagem. V arios programadores passaram a migrar seus c odigos para linguagens tais como Pascal, C e C++. Para levar a cabo mais uma moderniza c ao da linguagem, o comit e t ecnico X3J3, aprovado pela ANSI, trabalhando como o corpo de desenvolvimento do comit e da ISO (International Standards Organization, Organiza c ao Internacional de Padr oes) ISO/IEC JTC1/SC22/WG5 (doravante conhecido como WG5), preparou um novo padr ao, inicialmente conhecido como Fortran 8x, e agora como Fortran 90. Quais eram as justicativas para continuar com o processo de revis ao do padr ao da linguagem Fortran? Al em de padronizar extens oes comerciais, havia a necessidade de moderniza c ao, em resposta aos desenvolvimentos nos conceitos de linguagens de programa c ao que eram explorados em outras linguagens tais como APL, Algol, Pascal, Ada, C e C++. Com base nestas, o X3J3 podia usar os obvios benef cios de conceitos tais como ocultamento de dados. Na mesma linha, havia a necessidade de fornecer uma alternativa ` a perigosa associa c ao de armazenagem de dados, de abolir a rigidez agora desnecess aria do formato xo de fonte, bem como de aumentar a seguran ca na programa c ao. Para proteger o investimento em Fortran 77, todo o padr ao anterior foi mantido como um subconjunto do Fortran 90. Contudo, de forma distinta dos padr oes pr evios, os quais resultaram quase inteiramente de um esfor co de padronizar pr aticas existentes, o Fortran 90 e muito mais um desenvolvimento da linguagem, na qual s ao introduzidos recursos que s ao novos em Fortran, mas baseados em experi encias em outras linguagens. Os recursos novos mais signicativos s ao a habilidade de manipular matrizes usando uma nota c ao concisa mais poderosa e a habilidade de denir e manipular tipos de dados denidos pelo programador. O primeiro destes recursos leva a uma simplica c ao na escrita de muitos problemas matem aticos e tamb em torna o Fortran
Autor: Rudi Gaelzer IFM/UFPel Impresso: 12 de abril de 2010
Cap tulo 1. Introdu c ao
uma linguagem mais eciente em supercomputadores. O segundo possibilita aos programadores a express ao de seus problemas em termos de tipos de dados que reproduzem exatamente os conceitos utilizados nas sua elabora c oes.
1.2.1
Recursos novos do Fortran 90
Um resumo dos novos recursos e dado a seguir:

O Fortran 90 possui uma maneira para rotular alguns recursos antigos como em obsolesc encia (isto e, tornando-se obsoletos). Opera c oes de matrizes. Ponteiros. Recursos avan cados para computa c ao num erica usando um conjunto de fun c oes inquisidoras num ericas. Parametriza c ao dos tipos intr nsecos, permitindo o suporte a inteiros curtos, conjuntos de caracteres muito grandes, mais de duas precis oes para vari aveis reais e complexas e vari aveis l ogicas agrupadas. Tipos de dados derivados, denidos pelo programador, compostos por estruturas de dados arbitr arias e de opera c oes sobre estas estruturas. Facilidades na deni c ao de colet aneas denominadas m odulos, u teis para deni c oes globais de dados e para bibliotecas de subprogramas. Exig encia que o compilador detecte o uso de constru c oes que n ao se conformam com a linguagem ou que estejam em obsolesc encia. 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 cos DO. A habilidade de escrever subprogramas internos e subprogramas recursivos e de chamar subprogramas com argumentos opcionais. Aloca c ao din amica de dados (matrizes autom aticas, matrizes aloc aveis e ponteiros). Melhoramentos nos recursos de entrada/sa da de dados. V arios novos subprogramas intr nsecos.
Todos juntos, estes novos recursos contidos em Fortran 90 ir ao assegurar que o padr ao continue a ser bem sucedido e usado por um longo tempo. O Fortran 77 continua sendo suportado como um subconjunto durante um per odo de adapta c ao. Os procedimentos de trabalho adotados pelo comit e X3J3 estabelecem um per odo de aviso pr evio antes que qualquer recurso existente seja removido da linguagem. Isto implica, na pr atica, um ciclo de revis ao, que para o Fortran e de cerca de cinco anos. A necessidade de remo c ao de alguns recursos e evidente; se a u nica a c ao adotada pelo X3J3 fosse de adicionar novos recursos, a linguagem se tornaria grotescamente ampla, com muitos tens redundantes e sobrepostos. A solu c ao nalmente adotada pelo comit e foi de publicar como uma ap endice ao padr ao um conjunto de duas listas mostrando quais os tens que foram removidos e quais s ao os candidatos para uma eventual remo c ao. A primeira lista cont em os recursos removidos (deleted features ). A segunda lista cont em os recursos em obsolesc encia (obsolescent features ), os quais s ao considerados obsoletos e redundantes, sendo assim candidatos ` a remo c ao na pr oxima revis ao da linguagem.
1.2.2
Recursos em obsolesc encia do Fortran 90
Os recursos em obsolesc encia do Fortran 90 s ao:

IF aritm etico; desvio para uma declara c ao END IF a partir de um ponto fora de seu bloco; vari aveis reais e de dupla precis ao nas express oes de controle de um comando DO;
1.3. Uma revis ao menor: Fortran 95

naliza c ao compartilhada de blocos DO, bem como naliza c ao por uma declara c ao ou comando distintos de um CONTINUE ou de um END DO; declara c ao ASSIGN e comando GO TO atribu do; RETURN alternativo; comando PAUSE; especicadores FORMAT atribu dos; descritor de edi c ao H.
1.2.3
Recursos removidos do Fortran 90
Uma vez que Fortran 90 cont em o Fortran 77 como subconjunto, esta lista permaneceu vazia para o Fortran 90.
1.3
Uma revis ao menor: Fortran 95
Seguindo a publica c ao do padr ao Fortran 90 em 1991, dois signicativos desenvolvimentos posteriores referentes ` a linguagem Fortran ocorreram. O primeiro foi a continuidade na opera c ao dos dois comit es de regulamenta c ao do padr ao da linguagem: o X3J3 e o WG5; o segundo desenvolvimento foi a cria c ao do F orum Fortran de Alta Performance (High Performance Fortran Forum, ou HPFF). Logo no inicio de suas delibera c oes, os comit es concordaram na estrat egia de denir uma revis ao menor no Fortran 90 para meados da d ecada de 90, seguida por uma revis ao de maior escala para o in cio dos anos 2000. Esta revis ao menor passou a ser denominada Fortran 95. O HPFF teve como objetivo a deni c ao de um conjunto de extens oes ao Fortran tais que permitissem a constru c ao de c odigos port aveis quando se zesse uso de computadores paralelos para a solu c ao de problemas envolvendo grandes conjuntos de dados que podem ser representados por matrizes regulares. Esta vers ao do Fortran cou conhecida como o Fortran de Alta Performance (High Performance Fortran, ou HPF), tendo como linguagem de base o Fortran 90, n ao o Fortran 77. A vers ao nal do HPF consiste em um conjunto de instru c oes que cont em o Fortran 90 como subconjunto. As principais extens oes est ao na forma de diretivas, que s ao vistas pelo Fortran 90 como coment arios, mas que s ao reconhecidas por um compilador HPF. Contudo, tornou-se necess aria tamb em a inclus ao de elementos adicionais na sintaxe, uma vez que nem todos os recursos desejados puderam ser acomodados simplesmente na forma de diretivas. ` medida que os comit A es X3J3 e WG5 trabalhavam, este comunicavam-se regularmente com o HPFF. 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 ao da linguagem. De fato, os recursos do HPF constituem as novidades mais importantes do Fortran 95. As outras mudan cas consistem em corre c oes, clarica c oes e interpreta c oes do novo padr ao. Estas se tornaram prementes quando os novos compiladores de Fortran 90 foram lan cados no mercado e utilizados; notou-se uma s erie de erros e detalhes obscuros que demandavam repara c oes. Todas estas mudan cas foram inclu das no novo padr ao Fortran 95, que teve a sua vers ao inicial lan cada no pr oprio ano de 1995.2 O Fortran 95 e compat vel com o Fortran 90, exceto por uma pequena altera c ao na fun c ao intr nseca SIGN (se c ao 7.4.2) e a elimina c ao de recursos t picos do Fortran 77, declarados em obsolesc encia no Fortran 90. Os detalhes do Fortran 95 foram nalizados em novembro de 1995 e o novo padr ao ISO foi nalmente publicado em outubro de 1996.
1.3.1
Os novos recursos do Fortran 95 est ao discutidos ao longo desta apostila. Em rela c ao ao Fortran 90, foram introduzidos os seguintes recursos:
Concord ancia aprimorada com o padr ao de aritm etica de ponto utuante bin aria da IEEE (IEEE 754 ou IEC 559-1989). Rotinas (procedures) puras (se c ao 8.2.16). Rotinas (procedures) elementais (se c ao 8.2.17).
2 Fortran
95, Commitee Draft, May 1995. ACM Fortran Forum, v. 12, n. 2, June 1995.

Dealoca c ao autom atica de matrizes aloc aveis (p agina 61). Comando e construto FORALL (se c ao 6.10). Extens oes do construto WHERE (p agina 58). Fun c oes especicadoras. Inicializa c ao de ponteiro e a fun c ao NULL (se c ao 7.16). Inicializa c ao de componentes de tipo derivado (p agina 25). Fun c oes elementares CEILING, FLOOR e SIGN (se c oes 7.4.1 e 7.4.2). Fun c oes transformacionais (7.15). Subrotina intr nseca CPU_TIME (se c ao 7.17.2). Coment ario na entrada de uma lista NAMELIST (p agina 128). Descritores de edi c ao com largura de campo m nimo. Especica c ao gen erica na cl ausula END INTERFACE.
1.3.2
Os recursos abaixo entraram na lista em obsolesc encia do Fortran 95 e, portanto, pouco ou nada foram comentados ao longo desta Apostila.
Formato xo de fonte. Comando GO TO computado. Declara c ao de vari avel de caractere na forma CHARACTER*. Declara c oes DATA entre comandos execut aveis. Fun c oes denidas em uma linha (statement functions). Extens ao assumida de caracteres quando estas s ao resultados de fun c oes.
1.3.3
Cinco recursos foram removidos do padr ao da linguagem Fortran 95 e, portanto, n ao ser ao mais aceitos por compiladores que respeitam o padr ao Fortran 95.
Indices de la cos DO do tipo real (qualquer esp ecie). Declara c ao ASSIGN e comando GO TO atribu do e uso de um inteiro atribu do por ASSIGN em uma declara c ao FORMAT. Desvio para uma declara c ao END IF a partir de um ponto fora do bloco. Comando PAUSE. Descritor de edi c ao H.
1.4
O Fortran no S eculo XXI: Fortran 2003
O Fortran 2003 e novamente uma revis ao grande do padr ao anterior: Fortran 95. A vers ao curta (draft) do novo padr ao foi divulgada em nais de 20033 e tornou-se desde ent ao o novo padr ao da linguagem, embora at e o presente momento nenhum compilador apresenta suporte completo do novo padr ao. As grandes novidades introduzidas foram: um direcionamento ainda maior para programa c ao orientada a objeto, a qual oferece uma maneira efetiva de separar a programa c ao de um c odigo grande e complexo em tarefas independentes e que permite a constru c ao de novo c odigo baseado em rotinas j a existentes e uma capacidade expandida de interface com a linguagem C, necess aria para que os programadores em Fortran possam acessar rotinas escritas em C e para que programadores de C possam acessar rotinas escritas em Fortran. Esta Apostila n ao ir a abordar os novos recursos introduzidos pelo Fortran 2003, limitando-se a list a-los.
3 Ver
o draft em: http://www.dkuug.dk/jtc1/sc22/open/n3661.pdf.
1.4. O Fortran no S eculo XXI: Fortran 2003
1.4.1
Os principais recursos introduzidos pelo padr ao s ao:

Aprimoramentos dos tipos derivados: tipos derivados parametrizados, controle melhorado de acessibilidade, construtores de estrutura aperfei coados e nalizadores. Suporte para programa c ao orientada a objeto: extens ao de tipo e heran ca (inheritance), polimorsmo (polymorphism), aloca c ao din amica de tipo e rotinas (procedures) ligadas a tipo. Aperfei coamentos na manipula c ao de dados: componentes aloc aveis de estruturas, argumentos mudos aloc aveis, par ametros de tipo deferidos (deferred type parameters), atributo VOLATILE, especica c ao expl cita de tipo em construtores de matrizes e declara c oes de aloca c ao, aperfei coamentos em ponteiros, express oes de inicializa c ao estendidas e rotinas intr nsecas aperfei coadas. Aperfei coamentos em opera c oes de Entrada/Sa da (E/S) de dados: transfer encia ass ncrona, acesso de uxo (stream access), opera c oes de transfer encia especicadas pelo usu ario para tipos derivados, controle especicado pelo usu ario para o arredondamento em declara c oes FORMAT, constantes nomeadas para unidades pr e-conectadas, o comando FLUSH, regulariza c ao de palavras-chave e acesso a mensagens de erro. Ponteiros de rotinas (procedure pointers). Suporte para as exce c oes do padr ao de aritm etica bin aria de ponto utuante ISO/IEC 559, anteriormente conhecido como padr ao IEEE 754. Interoperabilidade com a linguagem de programa c ao C. Suporte aperfei coado para internacionaliza c ao: acesso ao conjunto de caracteres de 4 bytes ISO 10646 and escolha de v rgula ou ponto como separador de parte inteira e parte decimal em opera c oes de E/S num ericas formatadas. Integra c ao aperfei coada com o sistema operacional hospedeiro: acesso a argumentos de linha de comando, vari aveis de ambiente e mensagens de erro do processador.
1.4.2
Nesta lista permanecem tens que j a estavam na lista de obsolesc encia do Fortran 95. Os crit erios para inclus ao nesta lista continuam sendo: recursos redundantes e para os quais m etodos melhores estavam dispon veis no Fortran 95. A lista dos tens em obsolesc encia do Fortran 2003 e:
IF aritm etico. END DO compartilhado por dois ou mais la cos e t ermino de um la co em uma cl ausula distinta de END DO ou CONTINUE. RETURN alternativo. Comando GO TO computado. Fun c oes denidas em uma linha (statement functions). Declara c oes DATA entre comandos execut aveis. Fun c oes de caractere de extens ao assumida. Formato xo da fonte. Forma CHARACTER* da declara c ao CHARACTER.
1.4.3
Um recurso e removido do novo padr ao se este for considerado redundante e praticamente sem uso pela comunidade, devido a novos recursos muito mais u teis na constru c ao do c odigo. A lista de recursos removidos no Fortran 2003, divulgada no draft, repete os recursos removidos do Fortran 95. Portanto, nenhum outro recurso foi removido.
1.5
O novo padr ao: Fortran 2008
Embora ainda n ao exista nenhum compilador que suporte completamente o padr ao atual, Fortran 2003, j a est a em fase de conclus ao as discuss oes a respeito do padr ao futuro: Fortran 2008. A vers ao curta (draft) do novo padr ao deve ser divulgada ao nal do ano de 2008. O Fortran 2008, embora pelo procedimento adotado pelos comit es X3J3/WG5 devesse ser uma revis ao 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 ao foram plenamente divulgados para o p ublico em geral, mas alguns dos tens que ir ao compor o novo padr ao, por consenso, est ao listados a seguir.
1.5.1
Com base em material de divulga c ao obtido na World Wide Web, os seguintes recursos ser ao inclu dos:
Co-matrizes (co-arrays). BITS, originalmente denominados objetos sem tipo (TYPELESS). Macros inteligentes (no lugar de m odulos parametrizados). Atributo CONTIGUOUS. La cos DO concorrentes (DO CONCURRENT). Interoperabilidade de ponteiros, objetos aloc aveis, matrizes de forma assumida e argumentos opcionais. Execu c ao de programas externos. Ponteiro aloc avel em resolu c ao gen erica Rotina interna como argumento real Inicializa c ao de ponteiros com alvos distintos de NULL(). Rotinas intr nsecas estendidas. Opera c ao de E/S recursivas a distintas unidades. ...
1.6
Coment arios sobre a bibliograa
Para escrever esta apostila, z uso de um n umero restrito de publica c oes, algumas das quais s ao de livre acesso atrav es da internet.
Para informa c oes a respeito do padr ao existente na linguagem Fortran 77, a qual foi substitu da pelo Fortran 90/95, utilizei freq uentemente o livro de Clive Page: Professional Programers Guide to Fortran 77 [5]. A principal fonte de informa c ao sobre o padr ao do Fortran 90/95 foi o amplo livro de Michael Metcalf 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 a conhecem o Fortran 77, oferecido pela Universidade de Manchester [6]. O manual de refer encia ` a Linguagem Fortran 90/95 que acompanha o compilador intel tamb em foi freq uentemente consultado [1]. Informa c oes divulgadas sobre o Fortran 2003 foram obtidas do livreto de John Reid [7] e do livro de Stephen Chapman: Fortran 95/2003 for Scientists and Engineers [2].
1.7. Observa c oes sobre a apostila e agradecimentos
1.7
Observa c oes sobre a apostila e agradecimentos
Por se tratar de uma obra em constante revis ao, esta apostila pode conter (e conter a, invariavelmente) uma s erie de erros de ortograa, pontua c ao, acentua c ao, etc. Em particular, o texto n ao foi ainda revisado para se conformar com o novo acordo ortogr aco da Lingua Portuguesa. Certos pontos poderiam tamb em ser melhor discutidos e podem conter at e informa c oes n ao completamente corretas. Durante o desenvolvimento e divulga c ao desta apostila, algumas pessoas contribuiram com o seu aprimoramento ao apontar erros e inconsist encias e ao oferecer sugest oes quanto a sua estrutura e conte udo. Qualquer contribui c ao e bem vinda e pode ser enviada ao endere co eletr onico: rudi@ufpel.edu.br. Gostaria de agradecer publicamente as contribui c oes das seguintes pessoas: Leandro Tezani.
Cap tulo 2
Formato do C odigo-Fonte
Neste cap tulo estuda-se, inicialmente, um formato b asico para o programa-fonte em Fortran 90/95 e os tipos de vari aveis e suas caracter sticas b asicas.
2.1
Formato do programa-fonte
Em Fortran h a tr es formatos b asicos de arquivos que s ao utilizados: 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 denidas pela linguagem de programa c ao de alto n vel. Programa-Objeto. Trata-se do programa-fonte compilado pelo compilador. Esta e a transcri c ao realizada pelo compilador do programa-fonte fornecido pelo programador para uma linguagem de baixo n vel, como Assembler ou outro c odigo diretamente interpret avel pela CPU. O programa-objeto n ao pode ainda ser executado; e necess ario ainda passar-se pela fase do linking (tradu c ao livre: linkagem ). Programa execut avel. Ap os a fase de compila c ao, onde os programas objetos s ao criados, o agente de compila c ao aciona o linker, o qual consiste em um programa especial que agrupa os programas objetos de forma a criar um arquivo nal, o programa execut avel, o qual pode ser ent ao executado pelo programador. Nesta se c ao ser a apresentada a estrutura b asica de um programa-fonte em Fortran 90/95. O Fortran 90/95 suporta duas formas de c odigo-fonte: o formato antigo do Fortran 77, agora denominado formato xo e o novo formato livre. Fortran 77: O formato xo foi utilizado pelo Fortran desde a primeira vers ao at e o Fortran 77. Este formato foi determinado pelas restri c oes impostas pelos cart oes perfurados, que eram a u nica op c ao para entrar com o c odigo fonte. A estrutura do formato xo e a seguinte: Colunas 1-5: r otulos (labels ) para desvio de processamento do programa. Coluna 6: caractere de continua c ao de linha. Colunas 7-72: c odigo fonte. H a, ainda, a possibilidade de incluir o caractere C ou c na coluna 1, o que instrui o compilador a ignorar tudo que segue neste linha. Esta a a forma encontrada para se colocar coment arios dentro do c odigo fonte. Fortran 90/95: Nestas revis oes, a linguagem passou a suportar o formato livre, com as seguintes caracter sticas.
No formato livre n ao h a uma coluna espec ca para iniciar o programa. Pode-se come car a escrever o c odigo a partir da coluna 1 e a linha de c odigo pode se estender at e a coluna 132. Al em disso, os caracteres em branco s ao irrelevantes em qualquer lugar do c odigo, exceto quanto estiverem sendo utilizados entre ap ostrofes. Neste caso, cada caractere em branco ser a avaliado na composi c ao nal do string.
10
2.1. Formato do programa-fonte

Mais de uma instru c ao pode ser colocada na mesma linha. O separador de linhas padr ao e o pontoe-v rgula ;. M ultiplos ; em uma linha, com ou sem brancos, s ao considerados como um separador simples. Desta forma, a seguinte linha de c odigo e interpretada como 3 linhas em seq u encia:
A = 0; B = 0; C = 0
O caractere ampersand & e a marca de continua c ao, isto e, ele indica que a linha com instru c oes imediatamente posterior e continua c ao da linha onde o & foi digitado. Desta forma, s ao permitidas at e 39 linhas adicionais de c odigo. Como exemplo, a seguinte linha de c odigo:
X = (-Y + ROOT_OF_DISCRIMINANT)/(2.0*A) tamb em pode ser escrita usando o &: X = (-Y + ROOT_OF_DISCRIMINANT) /(2.0*A)
& &
Para entrar com coment arios em qualquer ponto do c odigo-fonte, o usu ario deve digitar o ponto de exclama c ao ! em qualquer coluna de uma linha. Todo o restante da linha ser a desprezado pelo compilador. Exemplo:
X = Y/A - B ! Soluciona a equa c~ ao linear. O programa Al o Mam ae. Como primeiro exemplo de programa em Fortran 90/95, considere o seguinte c odigo-fonte: program p r i m e i r o i m p l i c i t none print * , Al o Mam ae end program p r i m e i r o A forma mais simples de um programa em Fortran 90/95 e a seguinte: PROGRAM <nome_do_programa> <declara c~ oes de nomes de vari aveis> <comandos execut aveis> END PROGRAM <nome_do_programa> Comparando com o exemplo do programa primeiro, a declara c ao PROGRAM primeiro e sempre a primeira instru c ao de um programa. Ela serve para identicar o c odigo ao compilador. Em seguida v em as declara c~ oes de nomes de vari aveis. Neste ponto, s ao denidos os nomes das vari aveis a ser usadas pelo programa. Caso n ao seja necess ario declarar vari aveis, como no programa primeiro, e recomend avel incluir, pelo menos, a instru c ao implicit none. Esta instrui o compilador a exigir que todas as vari aveis usadas pelo programa tenham o seu tipo explicitamente denido.1 Ap os declaradas as vari aveis, v em os comandos execut aveis. No caso do programa primeiro, o u nico comando execut avel empregado foi print *, Al^ o Mam~ ae o qual tem como conseq u encia a impress ao do texto Al o Mam ae na tela do monitor, o qual e a chamada sa da padr ao. Finalmente, o programa e encerrado com a instru c ao end program primeiro Os recursos utilizados no programa primeiro ser ao explicados com mais detalhes neste e nos pr oximos cap tulos da apostila.
1 Os
tipos de vari aveis suportados pelo Fortran 95 s ao discutidos no cap tulo 3.
Cap tulo 2. Formato do C odigo-Fonte
11
2.2
Nomes em Fortran 90/95
Um programa em Fortran 90/95 faz refer encia a muitas entidades distintas, tais como programas, subprogramas, m odulos, vari aveis, etc. Os nomes destas entidades devem consistir em caracteres alfanum ericos, de 1 a 31 caracteres. Os caracteres alfanum ericos v alidos s ao:
Letras (a - z; A - Z). Numerais (0 - 9). O caractere underscore .
Au nica restri c ao e que o primeiro caractere seja uma letra. Os seguintes exemplos s ao v alidos: A A_COISA X1 MASSA Q123 TEMPO_DE_VOO j a estes exemplos n ao s ao v alidos: 1A (come ca com numeral) A COISA (espa co em branco) $SINAL (cont em caractere n ao alfanum erico).
2.3
Entrada e sa da padr oes
O Fortran 90 possui tr es comandos de entrada/sa da de dados. A maneira mais direta de denir valores de vari aveis ou de exibir os valores destas e atrav es dos dispositivos de entrada/sa da padr oes. O dispositivo padr ao de entrada de dados e o teclado. O comando de leitura para o programa ler os valores das vari aveis e: READ *, <lista de nomes de vari aveis> READ(*,*) <lista de nomes de vari aveis> onde na lista de nomes de vari aveis est ao listados os nomes das vari aveis que dever ao receber seus valores via teclado. O usu ario deve entrar com os valores das vari aveis separando-as por v rgulas. O dispositivo padr ao de sa da de dados e a tela do monitor. H a dois comandos de sa da padr ao de dados: PRINT *, [<mensagem>[,]][<lista de nomes de vari aveis>] WRITE(*,*) [<mensagem>[,]][<lista de nomes de vari aveis>] O programa a seguir instrui o computador a ler o valor de uma vari avel real a partir do teclado e, ent ao, 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 nf o rm 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 avel real a, cujo valor ser a lido pelo computador, a partir do teclado, importante salientar que a instru e ent ao impresso na tela do monitor. E c ao implicit none deve ser sempre a segunda linha de um programa, sub-programa ou m odulo, aparecendo antes do restante das declara c oes de vari aveis. Esta se c ao apresentou somente um uso muito simples dos recursos de Entrada/Sa da de dados. Uma descri c ao mais completa destes recursos ser a realizada no cap tulo 9 na p agina 121.
12
2.4. Conjunto de caracteres aceitos

Tabela 2.1: Caracteres especiais do Fortran 90/95
Caractere = + * / ( ) , . $ :
Nome/Fun c ao Igual Soma Subtra c ao Multiplica c ao Divis ao Par enteses esquerdo Par enteses direito V rgula Ponto decimal Cifr ao Dois pontos
Caractere ! % & ; ? ** < >
Nome/Fun c ao Espa co em branco Exclama c ao Aspas Porcentagem E comercial (ampersand) Ponto e v rgula Ponto de interroga c ao Pot encia Ap ostrofe Menor que Maior que
2.4
Conjunto de caracteres aceitos
No Fortran 90/95, os elementos b asicos, denominados de tokens, s ao os caracteres alfanum ericos, os 10 d gitos ar abicos, o underscore e o conjunto de caracteres especiais apresentados na tabela 2.1. Dentro da sintaxe da linguagem, n ao existem diferen cas entre letras mai usculas e min usculas.
Cap tulo 3
Tipos de Vari aveis

Em Fortran, h a cinco tipos intr nsecos de vari aveis: tr es tipos num ericos, inteiros, reais e complexos (em ingl es INTEGER, REAL e COMPLEX) e dois tipos n ao num ericos, caracteres e l ogicos (em ingl es CHARACTER e LOGICAL). O primeiro grupo de vari aveis e utilizado em opera c oes matem aticas e e o mais utilizado. O segundo grupo e utilizado para opera c oes que envolvem manipula c oes de texto ou opera c oes l ogicas. Em Fortran 90/95, cada um dos cinco tipos intr nsecos possui um valor inteiro n ao negativo denominado par ametro de esp ecie do tipo (em ingl es, kind type parameter ). A norma padr ao da linguagem determina que qualquer processador deve suportar pelo menos duas esp ecies para os tipos REAL e COMPLEX e pelo menos uma esp ecie para os tipos INTEGER, CHARACTER e LOGICAL. Um outro avan co do Fortran 90 sobre o predecessor Fortran 77 consiste na habilidade em denir novos tipos de vari aveis, baseados nos tipos intr nsecos. Estas s ao os chamados tipos derivados ou estruturas, os quais consistem em combina c oes de partes compostas por tipos intr nsecos e/ou por outros tipos derivados, permitindo gerar objetos de complexidade crescente. Neste cap tulo, vamos inicialmente denir o uso b asicos dos tipos intr nsecos de vari aveis, seguindo pela deni c ao das esp ecies de vari aveis mais comuns, terminando por denir os tipos derivados.
3.1
Declara c ao de tipo de vari avel
Como j a foi colocado anteriormente, e uma boa praxe de programa c ao iniciar o setor de declara c oes de vari aveis com a declara c ao IMPLICIT NONE a qual impede a possibilidade de haver nomes de vari aveis n ao denidos, os quais possuem o seu tipo impl cito, uma pr atica corriqueira em Fortran 77. A forma geral de uma declara c ao de tipo de vari aveis e: <tipo>[([KIND=]<par^ ametro de esp ecie>)][,<lista de atributos>] :: <lista de entidades>
onde <tipo> especica o tipo de vari avel, <par^ ametro de esp ecie> especica a esp ecie da vari avel, <lista de atributos> e um dos seguintes: PARAMETER PUBLIC PRIVATE POINTER TARGET ALLOCATABLE e cada entidade e <nome do objeto> [(lista de extens~ oes)] [*char-len] [= express~ ao de inicializa c~ ao] ou <nome da fun c~ ao> [*char-len] onde <nome do objeto> e o nome da vari avel, seguindo a regra de nomes v alidos denida no cap tulo 2. Os objetos restantes, em particular <par^ ametro de esp ecie> e <lista de atributos>, ser ao estudados ao longo do desenvolvimento desta apostila. 13 DIMENSION(<lista de extens~ oes>) INTENT(<inout>) OPTIONAL SAVE EXTERNAL INTRINSIC
14
3.2. Vari aveis do tipo INTEGER
3.2
Vari aveis do tipo INTEGER
Este tipo de vari avel armazena apenas a parte inteira de um n umero, exemplos de n umeros inteiros v alidos, tamb em denominados literais s ao: 123, 89312, 5. As declara c oes b asicas de nomes de vari aveis de tipo inteiro s ao: Fortran 77: INTEGER <lista de nomes de vari aveis> Fortran 90/95: INTEGER :: <lista de nomes de vari aveis>
O tipo de dados inteiro possui valores que pertencem ao conjunto dos n umeros inteiros. 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 a o pode c o n t e r ponto ( . ) Caso i s t o ! aco nte c a , v a i g e r a r um e r r o de e x e c u c a o no programa , ! 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 aveis do tipo REAL
O tipo de vari avel real e composto de quatro partes, assim dispostas: 1. uma parte inteira, com ou sem sinal, 2. um ponto decimal, 3. uma parte fracion aria e 4. um expoente, tamb em com ou sem sinal. Um ou ambos os itens 1 e 3 devem estar presentes. O item 4 ou est a ausente ou consiste na letra E seguida por um inteiro com ou sem sinal. Um ou ambos os itens 2 e 4 devem estar presentes. Exemplos de literais reais s ao: -10.6E-11 (representando 10, 6 1011 ) 1. -0.1 1E-1 (representando 101 ou 0,1) 3.141592653 Os literais reais s ao representa c oes do conjunto dos n umeros reais e o padr ao da linguagem n ao especica o intervalo de valores aceitos para o tipo real e nem o n umero de d gitos signicativos na parte fracion aria (item 3) que o processador suporta, uma vez que estes valores dependem do tipo de processador em uso. Valores comuns s ao: intervalo de n umeros entre 1038 a 10+38 , com uma precis ao de cerca de 7 (sete) d gitos decimais. As declara c oes b asicas do tipo real s ao: Fortran 77: REAL <lista de nomes de vari aveis> Fortran 90/95: REAL :: <lista de nomes de vari aveis>
Cap tulo 3. Tipos de Vari aveis 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 avel b e i n i c i a l i z a d a a 1 0 . 5 e 2. 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
15
3.4
Vari aveis do tipo COMPLEX
O Fortran, como uma linguagem destinada para c alculos cient cos ou em engenharia, tem a vantagem de possuir um terceiro tipo intr nseco: n umeros complexos. Este tipo e concebido como um par de literais, os quais s ao ou inteiros ou reais, separados por v rgula , e contidos entre par enteses ( e ). Os literais complexos representam n u meros contidos no conjunto dos n u meros complexos, isto e, n umeros do tipo e a parte real e y e a parte imagin aria do n umero complexo z . Assim, um z = x + iy, onde i = 1, x literal complexo deve ser escrito: (<parte real>,<parte imagin aria>) Exemplos de literais complexos s ao: (1.,3.2) (representando 1 + 3, 2i) (1.,.99E-2) (representando 1 + 0, 99 102 i) (1.0,-3.7) Uma outra grande vantagem do Fortran e que toda a algebra de n umeros complexos j a est a implementada a n vel de compilador. Assim, se for realizado o produto de dois n umeros complexos (x1,y1) e (x2,y2), o resultado ser a o literal complexo dado por (x1*x2 - y1*y2,x1*y2 + x2*y1). O mesmo acontecendo com as outras opera c oes alg ebricas. As declara c oes b asicas do tipo complexo s ao: Fortran 77: COMPLEX <lista de nomes de vari aveis> Fortran 90/95: COMPLEX :: Programa exemplo: program va r complexa i m p l i c i t none complex : : a= (5 , 5) , b , c ! V a r i avel a e i n i c i a l i z a d a a (5 , 5). 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 var complexa <lista de nomes de vari aveis>
3.5
Vari aveis do tipo CHARACTER
O tipo padr ao consiste em um conjunto de caracteres contidos em um par de ap ostrofes ou aspas. Os caracteres n ao est ao restritos ao conjunto de caracteres padr ao denidos na se c ao 2.4. Qualquer caractere que possa ser representado pelo processador e aceito, exceto os caracteres de controle tais como o return. Os ap ostrofes ou aspas servem como delimitadores dos literais de caractere e n ao s ao considerados parte integrante do conjunto. Ao contr ario das normas usuais, um espa co em branco e diferente de dois ou mais. Exemplos de literais de caractere:
16
3.6. Vari aveis do tipo LOGICAL bom Dia bomDia BRASIL Fortran 90 As declara c oes mais utilizadas para o tipo caractere s ao:
Fortran 77: character*<comprimento> <lista de nomes de vari aveis> ou character <nome 1>*<comp. 1>, [<nome 2>*<comp. 2>, ...] Fortran 90/95: character(len=<comprimento>) :: <lista de nomes de vari aveis>
onde <comprimento> indica a quantidade de caracteres contidos nas vari aveis. Todas as vari aveis denidas por esta declara c ao t em o mesmo n umero de caracteres. Se for informado um literal maior que <comprimento>, este ser a truncado; se for informado um literal menor que o declarado, o processador ir a preencher o espa co restante ` a direita com espa cos em branco. 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 importante mencionar aqui a regra particular para o formato de fonte dos literais de caractere que s E ao escritos em mais de uma linha: 1. Cada linha deve ser encerrada com o caractere & e n ao pode ser seguida por coment ario. 2. Cada linha de continua c ao deve ser precedida tamb em pelo caractere &. 3. Este par && n ao faz parte do literal. 4. Quaisquer brancos seguindo um & em nal de linha ou precedendo o mesmo caractere em in cio de linha n ao s ao partes do literal. 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 o a vida mentida & De um futuro imaginado! & & Aqui ` a beira do rio & Sossego sem ter raz~ ao. & Este seu correr vazio & Figura, an^ onimo e frio, & A vida, vivida em v~ ao. & & & & & & & & & & &
3.6
Vari aveis do tipo LOGICAL
O tipo l ogico dene vari aveis l ogicas. Uma vari avel l ogica s o pode assumir dois valores, verdadeiro e falso. A representa c ao dos dois estado poss veis de uma vari avel l ogica s ao:
.TRUE. Verdadeiro
Cap tulo 3. Tipos de Vari aveis

.FALSE. Falso.
17
As declara c oes do tipo l ogico s ao: Fortran 77: logical <lista de nomes de vari aveis> Fortran 90/95: logical :: 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 avel e verdadeira . end i f end program l o g i c o <lista de nomes de vari aveis>
3.7
O conceito de esp ecie (kind)
Em Fortran, al em dos 5 tipos de vari aveis denidos nas se c oes 3.2 a 3.6, e poss vel denir extens oes a um determinado tipo, cujas declara c oes dependem da vers ao do Fortran utilizada e do processador no qual o programa ser a executado.
3.7.1
Fortran 77
Em Fortran 77 as extens oes mais comuns e as correspondentes declara c oes s ao:

vari aveis reais de precis ao dupla: real*8 <lista de nomes de vari aveis> ou double precision <lista de nomes de vari aveis>. vari aveis reais de precis ao estendida (ou qu adrupla): real*16 <lista de nomes de vari aveis>. vari aveis complexas de precis ao dupla: complex*16 <lista de nomes de vari aveis>.
As diferen cas entre estas extens oes e os correspondentes tipos originais ser ao ilustradas a seguir.
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 ao negativo denominado par ametro de esp ecie do tipo (kind type parameter) . Por exig encia do padr ao, um processador deve suportar, no m nimo, duas esp ecies para os tipos REAL e COMPLEX e uma esp ecie para os tipos INTEGER, CHARACTER e LOGICAL. Os valores da esp ecie s ao dependentes do processador e/ou do compilador empregado. Contudo, h a fun c oes intr nsecas fornecidas pelo compilador que vericam as precis oes suportadas pelo processador e que podem ser usadas para denir o valor do par ametro KIND, possibilitando assim a portabilidade do c odigo, isto e, a possibilidade deste rodar em diferentes arquiteturas usando uma precis ao m nima especicada pelo programador. Para demonstrar como diferentes compiladores implementam e usam o par ametro de esp ecie, ser ao considerados os compiladores Intel Fortran Compiler for linux (vers ao 9.1), gfortran e o compilador 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 c oes de tipo e esp ecie: Tipo Inteiro. H a 04 par ametros de esp ecie para o tipo inteiro. Declara c ao: INTEGER([KIND=]<n>) [::] <lista de nomes de vari aveis> Sendo <n> das esp ecies 1, 2, 4 ou 8. Se o par ametro de esp ecie e explicitado, as vari aveis na <lista de nomes de vari aveis> ser ao da esp ecie escolhida. Em caso contr ario, a esp ecie ser a o inteiro padr ao: INTEGER(KIND=4); ou seja, a declara c ao INTEGER :: <lista de nomes de vari aveis> equivale a INTEGER(KIND=4) :: <lista de nomes de vari aveis>.
18
3.7. O conceito de esp ecie (kind)

Tabela 3.1: Tabela de armazenamento de vari aveis para o compilador Intel
Tipo e Esp ecie 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 ecie 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 ecies suportadas pelo compilador Intel
Fortran.
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 oes . r s i m p l e s= s q r t ( 2 . 0 ) ! Precis ao simples r d u p l a= s q r t ( 2 . 0 dp ) ! P r e c i s ao dupla r quad= s q r t ( 2 . 0 qp ) ! Precis ao qu a d r u p l a ou e s t e n d i d 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 a 03 par ametros de esp ecie para o tipo real. Declara c ao: REAL([KIND=]<n>) [::] <lista de nomes de vari aveis> Sendo <n> igual a 4, 8 ou 16. Caso o par ametro de esp ecie n ao seja especicado, a esp ecie ser a o real padr ao: REAL(KIND= 4). Tipo Complexo. H a 03 par ametros de esp ecie para o tipo complexo. Declara c ao: COMPLEX([KIND=]<n>) [::] <lista de nomes de vari aveis> Sendo <n> igual a 4, 8 ou 16. Caso o par ametro de esp ecie n ao seja explicitado, a esp ecie ser a o complexo padr ao: COMPLEX(KIND= 4). Tipo L ogico. H a 04 par ametros de esp ecie para o tipo l ogico. Declara c ao: LOGICAL([KIND=]<n>) [::] <lista de nomes de vari aveis> Sendo <n> igual a 1, 2, 4 ou 8. Tipo Caractere. H a somente uma esp ecie do tipo caractere. Declara c ao: CHARACTER([KIND=1],[LEN=]<comprimento>) [::] <lista de nomes de vari aveis>
Cada esp ecie distinta ocupa um determinado espa co de mem oria na CPU. Para o compilador Intel Fortran, o espa co ocupado est a descrito na tabela 3.1. O programa 3.1 a seguir ilustra do uso e as diferen cas de algumas op c oes de esp ecies de tipos de vari aveis. O mesmo programa tamb em indica o uso de alguns atributos na declara c ao de vari aveis, tais como na declara c ao INTEGER, PARAMETER :: DP= 2
O atributo PARAMETER indica que as vari aveis declaradas nesta senten ca devem se comportar como constantes matem aticas, isto e, n ao podem ser alteradas no programa por nenhuma atribui c ao de vari aveis (ver cap tulo 4). Na mesma declara c ao, j a est a sendo inicializado o valor do par ametro DP, sendo este igual a 2.

Tabela 3.2: Tabela de armazenamento de vari aveis para o compilador gfortran da funda ca o GNU.
19
Tipo e Esp ecie 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 ecie 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 em ilustra o uso da fun c ao impl cita SQRT(X): R_SIMPLES= SQRT(2.0) a qual calculou a raiz quadrada da constante 2.0 e atribuiu o resultado ` a vari avel R_SIMPLES. 3.7.2.2 Compilador gfortran
Gfortran e o compilador Fortran 95 da GNU (Funda c ao Gnu is Not Unix.), inicialmente desenvolvido como alternativa ao compilador f95 distribu do pelas vers oes comerciais do Unix. Atualmente, o gfortran e 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, entre outros. O comando gfortran consiste simplesmente em um script que invoca o programa f951, o qual traduz o c odigo-fonte para assembler, invocando em seguida o linkador e as bibliotecas comuns do pacote GCC. No gfortran, os par ametros de esp ecie s ao determinados de forma semelhante ao compilador Intel Fortran, discutido na se c ao 3.7.2.1, ou seja, o par ametro indica o n umero de bytes necess arios para armazenar cada vari avel da respectiva esp ecie de tipo. As esp ecies suportadas pelo gfortran s ao descritas na tabela 3.2. O programa testa_kind_gfortran a seguir (programa 3.2) ilustra o uso e as diferen cas entre as diversas esp ecies de tipos de dados no compilador gfortran. 3.7.2.3 Compilador F
Como exemplo do uso do par ametro de esp ecie, a tabela 3.3 ilustra os valores suportados pelo compilador F, conforme fornecidos pelo guia do usu ario2 . H a duas possibilidades para os n umeros da esp ecie: 1. o modo padr ao de opera c ao, tamb em denominado seq uencial, o qual pode, por em, ser especicado explicitamente no momento da compila c ao com a chave -kind=sequential; 2. o esquema de numera c ao bytes, o qual deve ser especicado no momento da compila c ao com a chave -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 cas de algumas op c oes de esp ecies de tipos de vari aveis. 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 oes . r s i m p l e s= s q r t ( 2 . 0 ) ! Precis ao simples
1 Em 2 The
plataformas de 64 bits, tais como a fam lia de processadores Intel Core 2. F Compiler and Tools (http://www.fortran.com/imagine1/ftools.pdf).
20
3.7. O conceito de esp ecie (kind)
Programa 3.2: Testa distintas esp ecies suportadas pelo compilador gfortran .
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

Tabela 3.3: Valores de esp ecies (kind) de tipos de vari aveis suportados pelo compilador F.
21
Tipo Real Real Real3 Complex Complex Complex Logical Logical Logical Logical Integer Integer Integer Integer Character
N umero do Kind (Sequ encial) 1 2 3 1 2 3 1 2 3 4 1 2 3 4 1
N umero do Kind (Byte) 4 8 16 4 8 16 1 2 4 8 1 2 4 8 1
Descri c ao Real precis ao simples (padr ao) Real precis ao dupla Real precis ao qu adrupla Complexo precis ao simples (padr ao) Complexo precis ao dupla Complexo precis ao qu adrupla L ogico 1 byte L ogico 2 bytes L ogico 4 bytes (padr ao) L ogico 8 bytes Inteiro 1 byte Inteiro 2 bytes Inteiro 4 bytes (padr ao) Inteiro 8 bytes Caractere, 1 byte por caractere
r d u p l a= s q r t ( 2 . 0 ) ! Precis ao dupla ! ! N u meros comp lexo s : p a r t e r e a l : r a i z de 2 . 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
P ar te i m a g i n a r i a : r a i z de 3 .
3.7.2.4
Literais de diferentes esp ecies
Para disting uir as esp ecies dos literais (ou constantes) dentre diferentes n umeros fornecidos ao compilador, utiliza-se o suxo _<k>, sendo <k> o par ametro da esp ecie do tipo: Literais inteiros. Constante inteiras, incluindo a esp ecie, s ao especicadas por: [<s>]<nnn...>[_<k>] onde: <s> e um sinal (+ ou ); obrigat orio se negativo, opcional se positivo. <nnn...> e um conjunto de d gitos (0 a 9); quaisquer zeros no in cio s ao ignorados. _<k> e um dos par ametros de esp ecie do tipo: 1, 2, 4 ou 8; esta op c ao explicita a esp ecie do tipo ` a qual o literal pertence. Literais reais. Constantes reais s ao especicadas de diferentes maneiras, dependendo se possuem ou n ao parte exponencial. A regra b asica para a especica c ao de um literal real j a foi denida na se c ao 3.3. Para explicitar a esp ecie do tipo real ` a qual o literal pertence, deve-se incluir o suxo _<k>, onde <k> e um dos par ametros de esp ecie do tipo: 4, 8 ou 16. Por exemplo: 2.0_8: para indicar tipo real, esp ecie 8. Literais complexos. A regra b asica para a especica c ao de um literal complexo j a foi denida na se c ao 3.4. Para explicitar a esp ecie do tipo ` a qual o literal pertence, deve-se incluir o suxo _<k>, onde <k> e um dos par ametros de esp ecie do tipo: 4, 8 ou 16, em cada uma das partes real e imagin aria do literal complexo. Por exemplo: (1.0_8,3.5345_8): para indicar tipo complexo, esp ecie 8. Literais l ogicos. Uma constante l ogica pode tomar uma das seguintes formas: .TRUE.[_<k>]
3 Vari aveis
reais e complexas de precis ao qu adrupla n ao s ao suportadas por todas as vers oes do compilador F.
22
3.7. O conceito de esp ecie (kind) .FALSE.[_<k>] onde <k> e um dos par ametros de esp ecie do tipo: 1, 2, 4 ou 8.
3.7.3
Fun c oes intr nsecas associadas ` a esp ecie
Embora as declara c oes de esp ecie do tipo possam variar para diferentes compiladores, o padr ao da linguagem estabelece um conjunto de fun c oes intr nsecas que facilitam a determina c ao e a declara c ao destas esp ecies de uma forma totalmente port avel, isto e, independente de compilador e/ou arquitetura. As fun c oes intr nsecas descritas nesta e nas subsequentes se c oes ser ao novamente abordadas no cap tulo 7, onde ser ao apresentadas todas as rotinas intr nsecas fornecidas pelo padr ao da linguagem Fortran 95. 3.7.3.1 KIND(X)
A fun c ao intr nseca KIND(X), a qual tem como argumento uma vari avel ou constante de qualquer tipo intr nseco, retorna o valor inteiro que identica a esp ecie da vari avel X. Por exemplo, 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) ! ! ! ! ! ! ! ! ! ! Retorna a esp ecie padr~ ao do tipo inteiro. (Dependente do processador). Retorna a esp ecie padr~ ao do tipo real. (Depende do processador). Retorna a esp ecie padr~ ao do tipo l ogico. (Depende do processador). Fornece a esp ecie padr~ ao de caractere. (Sempre igual a 1). Usualmente retorna a esp ecie do tipo real de precis~ ao dupla. (Pode n~ ao ser aceito por todos compiladores).
3.7.3.2
SELECTED_REAL_KIND(P,R)
A fun c ao intr nseca SELECTED_REAL_KIND(P,R) tem dois argumentos opcionais: P e R. A vari avel P especica a precis ao (n umero de d gitos decimais) m nima requerida e R especica o intervalo de varia c ao m nimo da parte exponencial da vari avel. A fun c ao SELECTED_REAL_KIND(P,R) retorna o valor da esp ecie que satisfaz, ou excede minimamente, os requerimentos especicados por P e R. Se mais de uma esp ecie satisfaz estes requerimentos, o valor retornado e aquele com a menor precis ao decimal. Se a precis ao requerida n ao for dispon vel, a fun c ao retorna o valor -1; se o intervalo da exponencial n ao for dispon vel, a fun c ao retorna -2 e se nenhum dos requerimentos for dispon vel, o valor -3 e retornado. Esta fun c ao, usada em conjunto com a declara c ao de esp ecie, garante uma completa portabilidade ao programa, desde que o processador tenha dispon veis os recursos solicitados. O exemplo a seguir ilustra o uso desta fun c ao intr 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
Cap tulo 3. Tipos de Vari aveis 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
23
Pode-se ver que a precis ao requerida na vari avel I10 e dispon vel na esp ecie correspondente ` a precis ao dupla de uma vari avel real para os compiladores mencionados (ver, por exemplo, tabela 3.2). Um outro recurso dispon vel e a possibilidade de especicar constantes de uma determinada esp ecie, como na atribui c ao A= 2.0_I10 A constante A foi explicitamente especicada como pertencente ` a esp ecie I10 seguindo-se o valor num erico com um underscore e com o par ametro de esp ecie do tipo (I10). Deve-se notar tamb em que a deni c ao da esp ecie I10, seguida da declara c ao das vari aveis A, B e C como sendo desta esp ecie, determina o intervalo m nimo de varia c ao da parte exponencial destas vari aveis. Se o par ametro da esp ecie associada ` a constante I10 for distinto do par ametro DP, a vari avel D n ao poderia ter sido declarada tamb em da esp ecie I10, pois a atribui c ao D= 1.0E201_I10 iria gerar uma mensagem de erro no momento da compila c ao, uma vez que a parte exponencial excede o intervalo denido para a esp ecie I10 (200). Contudo, para alguns compiladores, como o gfortran, a compila c ao ir a resultar em I10 = DP, tornando desnecess aria uma das declara c oes acima. Este exemplo demonstra a exibilidade e a portabilidade propiciada pelo uso da fun c ao intr nseca SELECTED_REAL_KIND. 3.7.3.3 SELECTED_INT_KIND(R)
A fun c ao intr nseca SELECTED_INT_KIND(R) e usada de maneira similar ` a fun c ao SELECTED_REAL_KIND. Agora, a fun c ao tem um u nico argumento R, o qual especica o intervalo de n umeros inteiros requerido. Assim, SELECTED_INT_KIND(r) retorna o valor da esp ecie que representa, no m nimo, valores inteiros no intervalo 10r a +10r . Se mais de uma esp ecie satisfaz o requerimento, o valor retornado e aquele com o menor intervalo no expoente r. Se o intervalo n ao for dispon vel, o valor -1 e retornado. O exemplo a seguir mostra a declara ca o de um inteiro de uma maneira independente do sistema: INTEGER, PARAMETER :: I8= SELECTED_INT_KIND(8) INTEGER(KIND= I8) :: IA, IB, IC As vari aveis inteiras IA, IB e IC podem ter valores entre 108 a +108 no m nimo, se dispon vel pelo processador.
3.8
Tipos derivados
Uma das maiores vantagens do Fortran 90/95 sobre seus antecessores est a na disponibilidade ao programador de denir seus pr oprios tipos de vari aveis. Estas s ao os chamados tipos derivados, tamb em freq uentemente denominados de estruturas. A forma geral da declara c ao de um tipo derivado e: TYPE [[,<acesso> ] ::] <nome do tipo > [PRIVATE] <declara c~ oes de componentes > END TYPE [<nome do tipo >] onde cada <declara c ao de componentes > tem a forma <tipo >[[, <atributos >] ::] <lista de componentes >
24
3.8. Tipos derivados
onde aqui o <tipo > pode ser um tipo de vari avel intr nseca ou outro tipo derivado. A declara c ao de uma lista de vari aveis do tipo derivado <nome do tipo > e feita atrav es da linha: TYPE (<nome do tipo >) [::] <lista de nomes> Para tentar-se entender o uso de uma vari avel de tipo derivado, vamos denir um novo tipo: PONTO, o qual ser a constru do a partir de tr es valores reais, representando os valores das coordenadas x, y e z do ponto no espa co cartesiano: 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, deniu-se o tipo derivado PONTO, composto por tr es componentes reais x, y e z. Em seguida, declarou-se duas vari aveis como sendo do tipo PONTO: CENTRO e APICE. A seguir, atribuiu-se os valores para estas vari aveis. Finalmente, mandou-se imprimir na tela o valor das vari aveis. Como foi mostrado na atribui c ao APICE%X= 0.0, cada componente da vari avel de tipo derivado pode ser referenciada individualmente por meio do caractere seletor de componente, %. J a a vari avel CENTRO teve os valores de suas componentes denidos 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 denidas desta forma podem ser interessantes quando o programador quer classicar determinados objetos caracterizados por par ametros e/ou qualicadores representados por vari aveis de diferentes poss tipos. E vel construirem-se estruturas progressivamente mais complicadas denindo-se novos tipos derivados que englobam aqueles previamente denidos. 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 denido o tipo RETA no espa co cartesiano, a qual e totalmente caracterizada por dois pontos, P1 e P2, os quais, por sua vez s ao ternas de n umeros do tipo (x, y, z ). Deniu-se ent ao a vari avel DIAGONAL_PRINCIPAL como sendo do tipo RETA e deniu-se os valores dos dois pontos no espa co P1 e P2 que caracterizam a diagonal principal. Note o uso de dois seletores de componente para denir o valor da coordenada x do ponto P1 da DIAGONAL_PRINCIPAL. Note, por outro lado, o uso do construtor de estrutura para denir a posi c ao do ponto P2, como componente da diagonal principal. O exemplo a seguir, dene o tipo ALUNO, caracterizado por NOME, CODIGO de matr cula, notas parciais N1, N2 e N3 e m edia nal MF. O programa l e as notas e calcula e imprime a m edia nal do aluno.
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 especicado quando o componente e declarado como parte da deni c ao do tipo. Se o componente n ao for um ponteiro, a inicializa c ao e feita de forma usual, com um sinal de igual seguido da express ao de inicializa c ao. Se o componente for um ponteiro, a u nica inicializa c ao admitida e o s mbolo de atribui c ao de um ponteiro (=>), seguida pela fun c ao intr nseca NULL() (se c ao 7.16). Em ambos os casos os caracteres :: s ao exigidos. Uma inicializa c ao n ao deve necessariamente se aplicar a todos os componentes de um tipo derivado. Um exemplo v alido seria: TYPE :: ENTRY REAL :: VALOR= 2.0 INTEGER INDEX TYPE(ENTRY), POINTER :: NEXT => NULL() END TYPE ENTRY Dada uma declara c ao de matriz tal como TYPE(ENTRY), DIMENSION(100) :: MATRIZ os sub-objetos tais como MATRIZ(3)%VALOR ter ao automaticamente o valor 2.0 e a seguinte opera c ao, que usa uma fun c ao intr nseca ASSOCIATED(MATRIX(3)%NEXT) vai retornar o valor .FALSE. (ver se c ao 7.3). Se as declara c oes de tipos derivados estiverem aninhadas, as inicializa c oes associadas a componentes s ao 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 a automaticamente o valor 2.0. Os componentes do tipo derivado continuam podendo ser inicializados em declara c oes de vari aveis do tipo, tais como TYPE(ENTRY), DIMENSION(100) :: MATRIZ= ENTRY(HUGE(0.0), HUGE(0), NULL()) em cuja situa c ao a inicializa c ao inicial e ignorada.
26
3.8. Tipos derivados
Cap tulo 4
Express oes e Atribui c oes Escalares

Em uma express ao, o programa descreve as opera c oes que devem ser executadas pelo computador. O resultado desta express ao pode ent ao ser atribu do a uma vari avel. H a diferentes conjuntos de regras para express oes e atribui c oes, dependendo se as vari aveis em quest ao s ao num ericas, l ogicas, caracteres ou de tipo derivado; e tamb em se as express oes s ao escalares ou matriciais. Cada um dos conjunto de regras para express oes escalares ser a agora discutido.
4.1
Regras b asicas
Uma express ao em Fortran 90/95 e formada de operandos e operadores, combinados de tal forma que estes seguem as regras de sintaxe. Os operandos podem ser constantes, vari aveis ou fun c oes e uma express ao, por si mesma, tamb em pode ser usada como operando. Uma express ao simples envolvendo um operador unit ario ou mon adico tem a seguinte forma: operador operando um exemplo sendo -Y J a uma express ao simples envolvendo um operador bin ario (ou di adico ) tem a forma: operando operador operando um exemplo sendo X + Y Uma express ao mais complicada seria operando operador operando operador operando onde operandos consecutivos s ao separados por um u nico operador. Cada operando deve ter valor denido e o resultados da express ao deve ser matematicamente denido; por exemplo, divis ao por zero n ao e permitido. A sintaxe do Fortran estabelece que as partes de express oes sem par enteses sejam desenvolvidas da esquerda para a direita para operadores de igual preced encia, com a exce c ao do operador ** (ver se c ao 4.2). Caso seja necess ario desenvolver parte de uma express ao, ou sub-express ao, antes de outra, par enteses podem ser usados para indicar qual sub-express ao deve ser desenvolvida primeiramente. Na express ao operando operador (operando operador operando) a sub-express ao entre par enteses ser a desenvolvida primeiro e o resultado usado como um operando para o primeiro operador, quando ent ao a express ao completa ser a desenvolvida usando a norma padr ao, ou seja, da esquerda para a direita. Se uma express ao ou sub-express ao n ao e contida entre par enteses, e permitido ao processador desenvolver uma express ao equivalente, a qual e uma express ao que resultar a no mesmo valor, exceto por erros de arredondamento num erico. As duas opera c oes a seguir s ao, em princ pio, equivalentes: 27
28
4.2. Express oes num ericas escalares A/B/C ou A/(B*C)
Poss veis diferen cas nos resultados das opera c oes acima consistem em diferentes erros de arredondamento e/ou tempo de processamento, caso o processador consiga multiplicar mais rapidamente que dividir. Se dois operadores seguem-se imediatamente, como em operando operador operador operando a u nica interpreta c ao poss vel e que o segundo operador e mon adico. Portanto, a sintaxe pro be que um operador bin ario siga outro operador, somente um operador unit ario.
4.2
Express oes num ericas escalares
Uma express ao num erica e aquela cujos operandos s ao um dos tr es tipos num ericos: inteiro, real e complexo. A tabela 4.1 apresenta os operadores, em ordem de preced encia, e o seu respectivo signicado. Estes operadores s ao conhecidos como operadores num ericos intr nsecos. Na tabela 4.1, as linhas horizontais connam os operadores de igual preced encia e a ordem de preced encia e dada de cima para baixo. O operador de potencia c ao ** e o de maior preced encia; os operadores de multiplica c ao * e divis ao / t em a mesma preced encia entre si e possuem preced encia sobre os operadores de adi c ao + e subtra c ao -, os quais t em a mesma preced encia entre si. Na aus encia de par enteses, ou dentro destes, no caso de sub-express oes, a opera c ao com a maior preced encia e o c alculo das fun c oes, seguidos das exponencia c oes que ser ao realizadas antes de multiplica c oes ou divis oes e estas, por sua vez, antes de adi c oes ou subtra c oes. Uma express ao num erica especica uma computa c ao usando constantes, vari aveis ou fun c oes, seguindo o seguinte conjunto de regras:
Os operadores de subtra c ao - e de adi c ao + podem ser usados como operadores unit arios, como em -VELOCIDADE Uma vez que n ao e permitido na nota c ao matem atica ordin aria, uma subtra c ao ou adi c ao unit aria n ao pode seguir imediatamente ap os outro operador. Quando isto e necess ario, deve-se fazer uso de par enteses. Por exemplo, as opera c oes matem aticas a seguir: xy deve ser digitada: X**(-Y); x(y ) deve ser digitada : X*(-Y). Como j a foi mencionado na se c ao 4.1, um operador bin ario tamb em n ao pode seguir outro operador. Os par enteses devem indicar os agrupamentos, como se escreve em uma express ao matem atica. Os par enteses indicam que as opera c oes dentro deles devem ser executadas prioritariamente: 3 (a + b) (x + y )2 + w2 deve ser digitada: (A+B)*((X+Y)**2 + W**2)**3 ou (A+B)*(((X+Y)**2 + W**2)**3) Os par enteses n ao podem ser usados para indicar multiplica c ao, sendo sempre necess ario o uso do operador *. Qualquer express ao pode ser envolvida por par enteses exteriores, que n ao a afetam: X + Y e equivalente a ((X) + Y) ou equivalente a ((X + Y)) Contudo, o n umero de par enteses ` a esquerda deve sempre ser igual ao n umero de par enteses ` a direita. Nenhum operador pode ser deixado impl cito: 5*T ou T*5: correto 5T, 5(T) ou T5: incorreto. De acordo com a tabela 4.1, a qual fornece o ordenamento dos operadores, a opera c ao matem atica 2x2 + y pode ser expressa de, no m nimo, duas maneiras equivalentes: 2*X**2 + Y ou 2*(X**2) + Y ou ainda (2*(x**2)) + Y.
Tabela 4.1: Operadores num ericos escalares
Operador ** * / + Autor: Rudi Gaelzer IFM/UFPel
Opera c ao Potencia c ao Multiplica c ao Divis ao Adi c ao Subtra c ao

Cap tulo 4. Express oes e Atribui c oes Escalares

Tabela 4.2: Tipos de resultados de A .op. B, onde .op. e +, -, * ou /.
29
Tipo de A I I I R R R C C C
Tipo de B I R C I R C I R C
Valor de A usado na .op. A REAL(A,KIND(B)) CMPLX(A,0,KIND(B)) A A CMPLX(A,0,KIND(B) A A A
Valor de B usado na .op. B B B REAL(B,KIND(A) B B CMPLX(B,0,KIND(A) CMPLX(B,0,KIND(A) B
Tipo de resultado I R C R R C C C C
Tabela 4.3: Tipos de resultados de A**B.
Tipo de A I I I R R R C C C
Tipo de B I R C I R C I R C
Valor de A usado na .op. A REAL(A,KIND(B)) CMPLX(A,0,KIND(B)) A A CMPLX(A,0,KIND(B) A A A
Valor de B usado na .op. B B B B B B B CMPLX(B,0,KIND(A) B
Tipo de resultado I R C R R C C C C
A exce c ao ` a regra esquerda-para-direita para operadores de igual preced encia ocorre para a potencia c ao **. A express ao A**B**C e v alida e e desenvolvida da direita para a esquerda como A**(B**C). Para dados inteiros, o resultado de qualquer divis ao ser a truncado para zero, isto e, para o valor inteiro cuja magnitude e igual ou logo inferior ` a magnitude do valor exato. Assim, o resultado de: 6/3 e2 8/3 e2 -8/3 e -2. Este fato deve sempre ser levado em conta quando divis oes de inteiros est ao sendo realizadas. Por isto, o valor de 2**3 e 8, enquanto que o valor de 2**(-3) e 0. A regra padr ao do Fortran 90 tamb em permite que uma express ao num erica contenha operandos num ericos de diferentes tipos ou esp ecies. Esta e uma express ao de modo misto. Exceto quando elevando um valor real ou complexo a uma pot encia inteira, o objeto do tipo mais fraco (ou mais simples) de vari avel dos dois tipos envolvidos em uma express ao ser a convertido, ou coagido, para o tipo mais forte. O resultado ser a tamb em do tipo mais forte. Por exemplo, se A e real e I e inteiro, a express ao A*I tem, inicialmente, I sendo convertido a real, antes que a multiplica c ao seja efetuada e o resultado da mesma e do tipo real. As tabelas 4.2 e 4.3 ilustram os resultados de diferentes opera c oes num ericas escalares. Com rela c ao ` a u ltima opera c ao mencionada na tabela 4.3, no case de um valor complexo ser elevado a uma pot encia tamb em complexa, o resultado corresponder a ao valor principal, isto e, ab = exp(b(log |a| + i arg a)), com < arg a < .
4.3
Atribui co es num ericas escalares

<nome vari avel> = <express~ ao>
A forma geral de uma atribui c ao num erica escalar e
30
4.4. Operadores relacionais
onde <nome vari avel> e o nome de uma vari avel num erica escalar e <express~ ao> e uma express ao num erica. Se <express~ ao> n ao e do mesmo tipo ou esp ecie da <vari avel>, a primeira ser a convertida ao tipo e esp ecie da u ltima antes que a atribui c ao seja realizada, de acordo com as regras dadas na tabela 4.4. Deve-se notar que se o tipo da vari avel for inteiro mas a express ao n ao, ent ao a atribui c ao ir a resultar em perda de precis ao, exceto se o resultado for exatamente inteiro. Da mesma forma, atribuindo uma express ao real a uma vari avel real de uma esp ecie com precis ao menor tamb em causar a perda de precis ao. Similarmente, a atribui c ao de uma express ao complexa a uma vari avel n ao complexa resultar a, no m nimo, na perda da parte imagin aria. Por exemplo, os valores de I e A ap os as atribui c oes I= 7.3 A= (4.01935, 2.12372) ! I do tipo inteiro. ! A do tipo real.
s ao, respectivamente, 7 e 4.01935.
4.4
Operadores relacionais
A tabela 4.5 apresenta os operadores relacionais escalares, utilizados em opera c oes que envolvem a compara c ao entre duas vari aveis ou express oes. Na coluna 1 da tabela, e apresentado o signicado do operador, na coluna 2 a sua forma escrita com caracteres alfanum ericos e, na coluna 3, a sua forma escrita com caracteres especiais. Fortran 77: somente a forma apresentada na coluna 2 e v alida. Fortran 90/95: qualquer uma das duas formas e v alida; por em, a forma apresentada na coluna 3 e a mais moderna e recomend avel, sendo a outra considerada obsoleta. Se uma ou ambas as express oes forem complexas, somente os operadores == e /= (ou .EQ. e .NE.) s ao dispon veis. O resultado de uma compara c ao deste tipo tem como resultado um dos dois valores l ogicos poss veis em uma algebra booleana: .TRUE. e .FALSE. e este tipo de teste e de crucial import ancia no controle do uxo do programa. Exemplos de express oes relacionais s ao dados abaixo, sendo I e J do tipo inteiro, A e B do tipo real e CHAR1 do tipo caractere padr ao: I .LT. 0 A I - J CHAR1 == Z ! ! ! ! express~ ao express~ ao express~ ao express~ ao relacional relacional relacional relacional inteira real de modo misto de caractere
Os operadores num ericos t em preced encia sobre os operadores relacionais. Assim, as express oes num ericas, caso existam, s ao desenvolvidas antes da compara c ao com os operadores relacionais. No terceiro exemplo acima, como as express oes envolvem dois tipos distintos, cada express ao e desenvolvida separadamente e ent ao ambas s ao convertidas ao tipo e esp ecie da soma dos resultados de cada express ao, de acordo com a tabela 4.2, antes que a compara c ao seja feita. Portanto, no exemplo, o resultado de (I - J) ser a convertido a real. Para compara c oes de caracteres, as esp ecies devem ser as mesmas e as as letras (ou n umeros ou caracteres especiais) s ao comparados da esquerda para a direita at e que uma diferen ca seja encontrada ou ambos os caracteres sejam id enticos. Se os comprimentos diferem, a vari avel mais curta e suposta preenchida por brancos ` a direita.
4.5
Express oes e atribui co es l ogicas escalares
Constantes, vari aveis e fun c oes l ogicas podem aparecer como operandos em express oes l ogicas. Os operadores l ogicos, em ordem decrescente de preced encia, s ao:
Tabela 4.4: Convers ao num erica para o comando de atribui ca o <nome vari avel> = <express~ ao>.
Tipo de <vari avel> I R C

Valor atribu do INT(<express~ ao>,KIND(<nome vari avel>) REAL(<express~ ao, KIND(<nome vari avel>) CMPLX(<express~ ao>,KIND(<nome vari avel>)
Cap tulo 4. Express oes e Atribui c oes Escalares

Tabela 4.5: Operadores relacionais em Fortran 90/95
31
Signicado Maior que Menor que Igual a Maior ou igual Menor ou igual Diferente de
Forma obsoleta .GT. .LT. .EQ. .GE. .LE. .NE.
Forma moderna > < == >= <= /=
Operador unit ario: .NOT. (nega c ao l ogica) Operadores bin arios: .AND. (intersec c ao l ogica, E l ogico) .OR. (uni ao l ogica, OU l ogico) .EQV. (equival encia l ogica) .NEQV. (n ao-equival encia l ogica). Dada ent ao uma declara c ao de vari aveis l ogicas do tipo LOGICAL :: I,J,K,L ent ao as seguintes express oes l ogicas s ao v alidas: .NOT. J J .AND. K I .OR. L .AND. .NOT. J (.NOT. K .AND. J .NEQV. .NOT. L) .OR. I Na primeira express ao o .NOT. e usado como operador unit ario. Na terceira express ao, as regras de preced encia implicam em que a sub-express ao L .AND. .NOT. J seja desenvolvida primeiro, e o resultado combinado com I. Na u ltima express ao, as duas sub-express oes .NOT. K .AND. J e .NOT. L ser ao desenvolvidas e comparadas para testar n ao-equival encia; o resultado da compara c ao ser a combinado com I. O resultado de qualquer express ao l ogica e .TRUE. ou .FALSE., e este valor pode ent ao ser atribu do a uma vari avel l ogica, tal como no exemplo abaixo: FLAG= (.NOT. K .EQV. L) .OR. J O resultado de uma express ao l ogica envolvendo duas vari aveis l ogicas A e B, por exemplo, pode ser inferido facilmente atrav es da consulta ` as Tabelas-Verdade 4.6 4.8. Uma vari avel l ogica pode ter um valor pr e-determinado por uma atribui c ao no corpo de comandos do programa: FLAG= .TRUE. ou no corpo de declara c oes de vari aveis: LOGICAL :: FLAG= .FALSE., BANNER= .TRUE., POLE Nos exemplos acima, todos os operando e resultados foram do tipo l ogico. Nenhum outro tipo de vari avel pode participar de uma opera c ao l ogica intr nseca, ou atribui c ao. Os resultados de diversas express oes relacionais podem ser combinados em uma express ao l ogica, seguida de atribui c ao, como no caso:
Tabela 4.6: Tabela-Verdade .NOT.
Tabela 4.7: Tabela-Verdade .AND.
Tabela 4.8: Tabela-Verdade .OR.
A T F
.NOT. A F T
A T T F F
B T F T F
A .AND. B T F F F
A T T F F
B T F T F
A .OR. B T T T F
32
4.6. Express oes e atribui c oes de caracteres escalares REAL :: A, B, X, Y LOGICAL :: COND . . . COND= A > B .OR. X < 0.0 .AND. Y > 1.0
onde os operadores relacionais t em preced encia sobre os operadores l ogicos. Contudo, o uso mais freq uente de express oes que envolvem operadores num ericos, relacionais e l ogicos ocorre em testes destinados a determinar o uxo do programa, como no caso do comando IF, exemplicado abaixo e que ser a discutido em mais detalhes no cap tulo 5: REAL :: A= 0.0, B= 1.0, X= 2.5, Y= 5.0 . . . IF((A < B) .AND. (X - Y > 0.0))THEN . . . IF((B**2 < 10.0) .OR. (A > 0.0))THEN . . . No primeiro teste IF acima, o resultado, levando em conta a hierarquia das preced encias nas diferentes opera c oes, e .FALSE. e os comandos contidos ap os a cl ausula THEN n ao ser ao executados. J a no segundo exemplo, o resultado e .TRUE. e os comandos ap os o THEN ser ao executados.
4.6
Express oes e atribui co es de caracteres escalares
Ou nico operador intr nseco para express oes de caracteres e o operador de concatena c ao //, o qual tem o efeito de combinar dois operandos de caracteres em um u nico caractere resultante, de extens ao igual ` a soma das extens oes dos operandos originais. Por exemplo, o resultado da concatena c ao das constantes de caractere AB e CD, escrita como AB//CD e a constante ABCD. Uma outra opera c ao poss vel com vari aveis de caracteres e a extra c ao de peda cos (substrings ) das vari aveis, os quais consistem em um determinado grupo de caracteres contidos na vari avel.
Substrings de caracteres.
Consideremos a seguinte declara c ao da vari avel de caractere HINO, a qual tem o comprimento igual a 236 caracteres e cujo valor e atribu do no momento da declara c ao: CHARACTER(LEN=236):: HINO = & Qual aurora precursora, do farol da divindade, &Foi o 20 de setembro, o precursor da liberdade. &Mostremos valor, const^ ancia, nesta mpia, injusta guerra. &Sirvam nossas fa canhas, de modelo ` a toda Terra (...) Pode-se isolar qualquer parte da vari avel HINO usando-se a nota c ao de substring HINO(I:J) onde I e J s ao vari aveis inteiras, as quais localizam explicitamente os caracteres de I a J em HINO. Os dois pontos : s ao usados para separar os dois ndices da substring e s ao sempre obrigat orios, mesmo que se queira isolar somente um caractere da vari avel. Alguns exemplos de substrings da vari avel HINO s ao: HINO(6:11) HINO(60:79) HINO(140:140) !Correspondente a aurora !Correspondente a Foi o 20 de setembro !Correspondente a ^ a & & &
As constantes de caracteres resultantes das substrings podem ser ent ao atribu das a outras vari aveis de caracteres. H a valores padr ao para os ndices das substrings. Se o ndice inferior e omitido, o valor 1 e assumido; se o valor superior e omitido, um valor correspondente ao comprimento da vari avel e assumido. Assim,
Cap tulo 4. Express oes e Atribui c oes Escalares HINO(:50) e equivalente a HINO(1:50) HINO(100:) e equivalente a HINO(100:236). Pode-se tamb em fazer concatena c oes com substrings: HINO(6:11)//HINO(69:79) gera a constante aurora de setembro TROCADILHO= HINO(153:157)//s//HINO(191:199) atribui ` a TROCADILHO o valor mpias fa canhas.
33
Se o resultado da express ao no lado direito for menor que o tamanho da vari avel, o valor e atribu do ` a vari avel come cando-se pela esquerda e o espa co restante e preenchido por brancos: CHARACTER(LEN= 10) :: PARTE1, PARTE2 PARTE1= HINO(178:183) ! Resulta em PARTE1= Sirvam
Ao passo que se o resultado da express ao foi maior que o tamanho da vari avel, esta ser a preenchida completamente e o restante do valor ser a truncado: PARTE2= HINO(:22) ! Resulta em PARTE2= Qual auror
Finalmente, e poss vel substituir parte de uma vari avel de caractere usando-se uma substring da mesma em uma atribui c ao: HINO(50:113)= AAAAAAAAAAARRRRRRRRRRRRRGGGGGGGGGGGGGHHHHHHHHHHHH!!!!!$%#$%%&%#%$# de tal forma que resulta, HINO = Qual aurora precursora, do farol da divindade, AAAAAAAAAAA& &RRRRRRRRRRRRRGGGGGGGGGGGGGHHHHHHHHHHHH!!!!!$%#$%%&%#%$# & &Mostremos valor, const^ ancia, nesta mpia, injusta guerra. & &Sirvam nossas fa canhas, de modelo ` a toda Terra (...) Os lados esquerdo e direito de uma atribui c ao podem ser sobrepor. Neste caso, ser ao sempre os valores antigos os usados no lado direito da express ao. Por exemplo, PARTE2(3:5) = PARTE2(1:3) resulta em PARTE2= QuQuaauror. Compara c oes e uso de operadores relacionais com vari aveis/constantes de caracteres s ao poss veis entre caracteres u nicos, inclusive com os operadores > e <. Neste caso, n ao se trata de testar qual caractere e maior ou menor que outro. Em um sistema computacional, caracteres possuem uma propriedade denominada seq u encia de intercala ca o,1 a qual ordena o armazenamento destes caracteres pelo sistema. O Fortran 90/95 determina que a seq u encia de intercala c ao para qualquer arquitetura deve satisfazer as seguintes condi c oes:
A precede ( e menor) que B, que precede C ... precede Y, que precede Z. 0 precede 1, que precede 2 ... precede 8, que precede 9. Espa co em branco precede A e Z precede 0; ou branco precede 0 e 9 precede A.
Se letras min usculas s ao dispon veis, ent ao

a precede b, que precede c, ... precede y, que precede z. Espa co em branco precede a e z precede 0; ou branco precede 0 e 9 precede a.
Assim, n ao h a regra que estabele ca que os n umeros devem preceder ou n ao as letras, nem tampouco h a regra de preced encia para caracteres especiais. De acordo com estas regras, as express oes relacionais A < B 0 < 1
1 Collating
sequence.
34
4.6. Express oes e atribui c oes de caracteres escalares

Tabela 4.9: Tabela de c odigos ASCII de 7 bits.
Dec 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
Hex 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
Char NUL SOH STX ETX EOT ENQ ACK BEL BS TAB LF VT FF CR SO SI DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
(null) (start of heading) (start of text) (end of text) (end of transmission) (enquiry) (acknowledge) (bell) (backspace) (horizontal tab) (line feed, new line) (vertical tab) (form feed, new page) (carriage return) (shift out) (shift in) (data link escape) (device control 1) (device control 2) (device control 3) (device control 4) (negative acknowledge) (synchronous idle) (end of trans. block) (cancel) (end of medium) (substitute) (escape) (le separator) (group separator) (record separator) (unit separator)
Dec 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
Hex 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
Char Space ! # $ % & ( ) * + , . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
Dec 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
Char @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ]
Dec 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
Char a b c d e f g h i j k l m n o p q r s t u v w x y z { | } DEL
fornecem ambas o resultado T (true). Fortran 90/95 fornece acesso tamb em ` a seq u encia de intercala c ao original da tabela ASCII2 atrav es de fun c oes intr nsecas (se c ao 7.6.1). ASCII consiste em uma padroniza c ao para um encodeamento de caracteres3 de 7 bits (originalmente), baseado no alfabeto ingl es. C odigos ASCII representam textos em computadores, equipamentos de comunica c ao e outros dispositivos eletr onicos que trabalham com texto. A tabela 4.9 mostra os caracteres ASCII originais, juntamente com os seus identicadores nos sistemas num ericos decimal, hexadecimal e octal, bem como o c odigo html correspondente. Os primeiros 32 (0 31) caracteres mais o caractere 127 s ao caracteres de controle, destinados ` a comunica c ao com perif ericos; estes n ao geram caracteres que podem ser impressos. J a os caracteres restantes (32 126) comp oe-se de caracteres alfanum ericos mais caracteres especiais.
2 American 3 Character
Standard Code for Information Interchange (ASCII). encoding.
Cap tulo 5
Comandos e Construtos de Controle de Fluxo

Nos cap tulos anteriores foi descrito como comandos de atribui c ao devem ser escritos e como estes podem ser ordenados um ap os o outro para formar uma seq u encia de c odigo, a qual e executada passo-a-passo. Na maior parte das computa c oes, contudo, esta seq u encia simples de comandos e, por si s o, inadequada para a formula c ao do problema. Por exemplo, podemos desejar seguir um de dois poss veis caminhos em uma se c ao de c odigo, dependendo se um valor calculado e positivo ou negativo. Como outro exemplo, podemos querer somar 1000 elementos de uma matriz; escrever 1000 adi c oes e atribui c oes e uma tarefa claramente tediosa e n ao muito eciente. Ao inv es, a habilidade de realizar uma itera c ao sobre uma u nica adi c ao e necess aria. Podemos querer passar o controle de uma parte do programa a outra ou ainda parar completamente o processamento. Para estes prop ositos, recursos s ao dispon veis em Fortran que possibilitam o controle do uxo l ogico atrav es dos comandos no programa. Os recursos contidos em Fortran 90 correspondem aos que agora s ao geralmente reconhecidos como os mais apropriados para uma linguagem de programa c ao moderna. Sua forma geral e a de um construto de bloco (do ingl es block construct ), o qual e um construto (uma constru c ao ou estrutura) que come ca com uma palavra-chave inicial, pode ter palavras-chave intermedi arias e que termina com uma palavra-chave nal que identica a palavra inicial. Cada seq u encia de comandos entre as palavras-chave e chamada de um bloco. Um bloco pode ser vazio, embora tais casos sejam raros. Construtos execut aveis podem ser aninhados (em ingl es, nested ) ou encadeados, isto e, um bloco pode conter um outro construto execut avel. Neste caso, o bloco deve conter o construto interno por inteiro. Execu c ao de um bloco sempre inicia com o seu primeiro comando execut avel. Os primeiros comandos de controle de uxo a ser mencionados ser ao aqueles que foram denidos tanto no Fortran 77 quanto no Fortran 90/95, seguidos daqueles que somente existem no Fortran 90/95.
5.1
Comandos obsoletos do Fortran 77
Os comandos descritos nesta se c ao fazem parte do padr ao do Fortran 77 mas que s ao considerados obsoletos no Fortran 90/95. O seu uso em um programa escrito nas u ltimas vers oes da linguagem e fortemente desencorajado e, para alguns compiladores, proibido. A raz ao para este status de obsoleto e porque estes comandos facilmente geram diculdades e d ao margem a confus ao durante a leitura do programa. Algumas raz oes para o status de obsoleto para estes comandos s ao apresentadas abaixo.
5.1.1
R otulos (statement labels)
Um r otulo consiste em um n umero inteiro, de 1 a 99999, inserido entre as colunas 1 e 5 de um programa ou sub-programa em Fortran 77 escrito, portanto, no formato xo. Este r otulo enfatiza o ponto do c odigo onde ele se encontra. H a tr es raz oes para se usar um r otulo: 1. O nal de um la co DO e especicado por um r otulo determinado no in cio do mesmo la co. 2. Todo comando FORMAT deve possuir um r otulo, pois esta e a maneira como os comandos READ e WRITE fazem refer encia ao mesmo. 3. Qualquer comando execut avel pode possuir um r otulo axado, de tal forma que o uxo do c odigo pode ser transferido ao mesmo. Isto e realizado, por exemplo, pelo comando GO TO. 35
36 Exemplo:
5.1. Comandos obsoletos do Fortran 77
c (F77) L^ e n umeros de um arquivo de entrada at e que ele termine, ent~ ao os soma. SUMA= 0.0 100 READ(UNIT= IN, FMT= 200, END= 9999) VALOR 200 FORMAT(F20.0) SOMA= SOMA + VALOR GO TO 100 9999 CONTINUE WRITE(UNIT= *, FMT=*)SOMA dos valores e:, SOMA O comando CONTINUE signica, literalmente, continue, isto e, ele apenas instrui o programa a continuar a partir daquele ponto.
5.1.2
Comando GO TO incondicional
O comando GO TO incondicional simplesmente transfere o uxo do c odigo para um comando rotulado em algum outro ponto do programa. Sua forma geral e: GO TO <r otulo> Um exemplo de aplica c ao deste comando pode ser visto acima. A u nica exce c ao para seu uso e a proibi c ao de transferir o uxo para dentro de um bloco IF ou la co DO; entretanto, e permitido transferir o uxo com o comando GO TO, ou outro, para fora de um bloco IF ou la co DO. O uso do GO TO incondicional torna poss vel escrever-se programas com uma estrutura bastante indisciplinada. Tais programas s ao usualmente dif ceis de ser compreendidos e corrigidos. Bons programadores usam este comando raras vezes ou nunca. Contudo, no Fortran 77 em algumas situa c oes n ao era poss vel evit a-lo, devido a falta de alternativas de estruturas de controle.
5.1.3
Comando GO TO computado
O comando GO TO computado e uma alternativa para um bloco IF para as situa c oes em que um n umero grande de op c oes devem ser consideradas e elas podem ser selecionadas por uma express ao de valores inteiros. A forma geral do comando e: GO TO (<r otulo 1>, <r otulo 2>, ..., <r otulo N>)[,] <express~ ao inteira> A <express~ ao inteira> e desenvolvida; se o seu resultado e 1 (um), o controle e transferido ao comando axado ao <r otulo 1>; se o resultado e 2 (dois), o controle e transferido ao comando axado ao <r otulo 2> e assim por diante. Se o resultado da express ao e menor que um ou maior que N (havendo N r otulos na lista), o comando n ao tem efeito e o uxo do programa continua com o pr oximo comando em seq u encia. O mesmo r otulo pode estar presente mais de uma vez na lista. O GO TO computado sofre das mesmas desvantagens que o GO TO incondicional, uma vez que se suas ramica c oes forem usadas sem cuidado, o programa se torna ileg vel de t ao confuso.
5.1.4
Comando IF aritm etico
A forma geral do comando IF aritm etico e: IF (<express~ ao aritm etica>) <r otulo 1>,<r otulo 2>,<r otulo 3> Este comando geralmente fornece uma ramica c ao com tr es possibilidades, embora dois dos r otulos possam ser iguais, o que o torna uma ramica c ao de duas possibilidades. A <express~ ao aritm etica> pode ser inteira, real ou real de precis ao dupla. O controle do uxo e transferido ao comando axado ao <r otulo 1> se o valor for negativo, ao <r otulo 2> se for zero e ao <r otulo 3> se for positivo.
5.1.5
Comandos ASSIGN e GO TO atribu do
Estes dois comandos s ao normalmente usados juntos. O comando ASSIGN atribui o valor de um r otulo a uma vari avel inteira. Quando isto e realizado, a vari avel n ao mais possui um valor aritm etico, mas se torna o pr oprio r otulo. Se o r otulo e axado a um comando execut avel, a vari avel somente pode ser usada em um comando GO TO atribu do; se e axado a um comando FORMAT, a vari avel somente pode ser usada em um comando READ ou WRITE. As formas gerais destes comandos s ao:
Cap tulo 5. Comandos e Construtos de Controle de Fluxo ASSIGN <r otulo> TO <vari avel inteira> GO TO <vari avel inteira> [,] [(<r otulo>,<r otulo>,...,<r otulo>)]
37
Um GO TO atribu do pode ser usado para fornecer uma liga c ao para e a partir de uma se c ao de um programa ou sub-programa, atuando assim como um subrotina interna.
5.1.6
La cos DO rotulados
O comando DO controla um bloco de comandos os quais s ao executados repetidas vezes, uma vez para cada valor de uma vari avel denominada vari avel de controle do la co (loop-control variable) . O n umero de itera c oes depende dos par ametros do comando DO no cabe calho do la co. A primeira vers ao de um bloco ou la co DO cont em um r otulo que indica o u ltimo comando do la co. A forma geral do cabe calho de um la co DO rotulado pode ter uma das duas formas seguintes: DO <r otulo> [,] <vari avel> = <in cio>, <limite>, <passo> DO <r otulo> [,] <vari avel> = <in cio>, <limite> Na segunda forma, o tamanho do passo e implicitamente igual a um. O <r otulo> marca o u ltimo comando do la co. Ele deve estar axado a um comando execut avel em alguma linha posterior do programa ou subprograma. A regra permite que este comando seja qualquer comando execut avel, exceto outro comando de controle (como o IF, por exemplo), mas e recomend avel que se use o comando CONTINUE, cuja fun c ao foi exemplicada na se c ao 5.1.1. A <vari avel> e a vari avel de controle do la co ou ndice do la co; ela deve ser uma vari avel escalar (n ao um elemento de matriz) e pode ser dos tipos inteiro, real ou dupla precis ao. Os valores de <in cio>, <limite> e <passo> podem ser express oes tamb em dos tipos inteiro, real ou precis ao dupla. Se o valor do <passo> estiver presente, este n ao pode ser zero; se for omitido, o seu valor e assumido igual a um. O n umero de itera c oes a ser realizadas e calculado antes do in cio da primeira itera c ao e e dado pela f ormula: itera c~ oes = MAX(0,INT((limite - in cio + passo)/passo)) onde a fun c ao impl cita INT toma a parte inteira do argumento por truncagem e a fun c ao MAX toma o maior valor dos seus dois argumentos. Nota-se que se o valor de limite e menor que in cio, o n umero de itera c oes e zero, exceto no case de passo ser negativo. Um n umero nulo de itera c oes e permitido, mas isto signica que o conte udo do la co n ao ser a executado e o controle do uxo e transferido ao primeiro comando ap os o r otulo. A vari avel de controle do la co n ao necessariamente assume o valor limite, especialmente se o tamanho do passo for maior que um e/ou do tipo real com valor fracion ario. Comandos dentro do la co podem alterar o valor das express oes usadas para o in cio, limite ou passo, mas o n umero de itera c oes n ao e alterado, uma vez que este e determinado antes do in cio da primeira itera c ao. A vari avel de controle do la co pode ser usada em express oes mas um novo valor n ao pode ser atribu do a ela dentro do la co. Dois exemplos de aplica c oes de la cos DO rotulados: c Soma dos quadrados dos N primeiros elementos da matriz X. SOMA= 0.0 DO 15, I= 1,N SOMA= SOMA + X(I)**2 15 CONTINUE ------------------------------C Inicializa as componentes da matriz FIELD iguais a zero. c Exemplo de la cos DO encadeados. REAL FIELD(NX, NY) DO 50, IY= 1,NY DO 40, IX= 1,NX FIELD(IX, IY)= 0.0 40 CONTINUE 50 CONTINUE
5.2
Comando e construto IF
O comando IF fornece um mecanismo para controle de desvio de uxo, dependendo de uma condi c ao. H a duas formas: o comando IF e o construto IF, sendo o u ltimo uma forma geral do primeiro.
38
5.2. Comando e construto IF
5.2.1
Comando IF
No comando IF, o valor de uma express ao l ogica escalar e testado e um u nico comando e executado se e somente se o seu valor for verdadeiro. A forma geral e: IF (<express~ ao relacional e/ou l ogica>) <comando execut avel> O <comando execut avel> e qualquer, exceto aqueles que marcam o in cio ou o nal de um bloco, como por exemplo IF, ELSE IF, ELSE, END IF, outro comando IF ou uma declara c ao END. Temos os seguintes exemplos: IF (FLAG) GO TO 6 IF(X-Y > 0.0) X= 0.0 IF(COND .OR. P < Q .AND. R <= 1.0) S(I,J)= T(J,I)
5.2.2
Construto IF
Um construto IF permite que a execu c ao de uma seq u encia de comandos (ou seja, um bloco) seja realizada, dependendo de uma condi c ao ou de um outro bloco, dependendo de outra condi c ao. H a tr es formas usuais para um construto IF. A forma mais simples tem a seguinte estrutura geral: [<nome>:] IF (<express~ ao relacional e/ou l ogica>) THEN <bloco> END IF [<nome>] onde <bloco> denota uma seq u encia de linhas de comandos execut aveis. O bloco e executado somente se o resultado da <express~ ao relacional e/ou l ogica> for verdadeiro. O construto IF pode ter um <nome>, o qual deve ser um nome v alido em Fortran 90/95. O <nome> e opcional, mas se for denido no cabe calho do construto, ele deve ser tamb em empregado no nal, denotado pela declara c ao END IF <nome>. Como exemplo, temos: SWAP: IF (X < Y) THEN TEMP= X X= Y Y= TEMP END IF SWAP As tr es linhas de texto entre SWAP: IF ... e END IF SWAP ser ao executadas somente se X < Y. Pode-se incluir outro construto IF ou outra estrutura de controle de uxo no bloco de um construto IF. A segunda forma usada para o construto IF e a seguinte: [<nome>:] IF (<express~ ao relacional e/ou l ogica>) THEN <bloco 1> ELSE [<nome>] <bloco 2> END IF [<nome>] Na qual o <bloco 1> e executado se o resultado da <express~ ao relacional e/ou l ogica> for verdadeira; caso contr ario, o <bloco 2> ser a executado. Este construto permite que dois conjuntos distintos de instru c oes sejam executados, dependendo de um teste l ogico. Um exemplo de aplica c ao desta forma intermedi aria seria: IF (X < Y) THEN X= -Y ELSE Y= -Y END IF Neste exemplo, se o resultado de X < Y for verdadeiro, ent ao X= -Y, sen ao (ou seja, X >= Y) a a c ao ser a Y= -Y. A terceira e nal vers ao usa a instru c ao ELSE IF para realizar uma s erie de testes independentes, cada um dos quais possui um bloco de comandos associado. Os testes s ao realizados um ap os o outro at e que um
Cap tulo 5. Comandos e Construtos de Controle de Fluxo
39
deles seja satisfeito, em cujo caso o bloco associado e executado, enquanto que os outros s ao solenemente ignorados. Ap os, o controle do uxo e transferido para a instru c ao END IF. Caso nenhuma condi c ao seja satisfeita, nenhum bloco e executado, exceto se houver uma instru c ao ELSE nal, que abarca quaisquer possibilidades n ao satisfeitas nos testes realizados no construto. A forma geral e: [<nome>:] IF (<express~ ao relacional e/ou l ogica>) THEN <bloco> [ELSE IF (<express~ ao relacional e/ou l ogica>) THEN [<nome>] <bloco>] ... [ELSE [<nome>] <bloco>] END IF [<nome>] Pode haver qualquer n umero (inclusive zero) de instru c oes ELSE IF e, no m aximo, uma instru c ao ELSE. Novamente, o <nome> e opcional, mas se for adotado no cabe calho do construto, ent ao deve ser mencionado em todas as circunst ancias ilustradas acima. O exemplo a seguir ilustra o encadeamento de construtos IF. Estruturas ainda mais complicadas s ao poss veis, mas neste caso e recomend avel adotar nomes para os construtos, como forma de facilitar a leitura e compreens ao do programa. IF (I < 0) THEN IF (J < 0) THEN X= 0.0 Y= 0.0 ELSE Z= 0.0 END IF ELSE IF (K < 0) THEN Z= 1.0 ELSE X= 1.0 Y= 1.0 END IF O programa-exemplo a seguir (programa 5.1) faz uso de construtos IF para implementar o c alculo do fatorial de um n umero natural, j a utilizando o construto DO, abordado na se c ao 5.3.
5.3
Construto DO
Um la co DO e usado quando for necess ario calcular uma s erie de opera c oes semelhantes, dependendo ou n ao de algum par ametro que e atualizado em cada in cio da s erie. Por exemplo, para somar o valor de um polin omio de grau N em um dado ponto x:
N
P (x) = a0 + a1 x + a2 x2 + + aN xN =
i=0
ai xi .
Outro tipo de opera c oes freq uentemente necess arias s ao aquelas que envolvem opera c oes matriciais, como o produto de matrizes, triangulariza c ao, etc. Para este tipo de opera c oes repetidas, e conveniente usar-se um la co DO para implement a-las, ao inv es de escrever o mesmo bloco de opera c oes N vezes, como aconteceria se fosse tentado implementar a soma do polin omio atrav es das seguintes express oes: REAL POL= POL= POL= ... POL= :: POL,A0,A1,A2,...,AN A0 POL + A1*X POL + A2*X**2 POL + AN*X**N
Esta forma do la co DO n ao usa r otulos, como a forma denida na se c ao 5.1.6. A forma geral de um construto DO e a seguinte:
40
5.3. Construto DO
Programa 5.1: Programa que utiliza os construtos IF e DO.
program i f f a t ! C a l c u l a o f a t o r i a l de um n u mero n a t u r a l . i m p l i c i t none integer : : i , f a t , j ! print * , Entre com v a l o r : read * , i i f ( i < 0 ) then print * , N ao e p o s s vel calcular o fatorial . e l s e i f ( i == 0 ) then print * , f a t ( , i , )= , 1 else f a t= 1 do j= 1 , i f a t= f a t * j end do print * , f a t ( , i , )= , f a t end i f end program i f f a t
[<nome>:] DO [<vari avel> = <express~ ao 1>, <express~ ao 2> [, <express~ ao 3>]] <bloco> END DO [<nome>] onde <vari avel> e uma vari avel inteira e as tr es express oes contidas no cabe calho do construto devem ser do mesmo tipo. No cabe calho acima, cada uma das express oes indica: <express~ ao 1>: o valor inicial da <vari avel>; <express~ ao 2>: o valor m aximo, ou limite, da <vari avel> (n ao necessariamente deve ser o u ltimo valor assumido pela vari avel); <express~ ao 3>: o passo, ou incremento, da vari avel em cada nova itera c ao. Este construto tamb em e aceito no Fortran 77, exceto pela possibilidade de se denir um <nome>. Como no caso de um la co DO rotulado, o n umero de itera c oes e denido antes de se executar o primeiro comando do <bloco> e e dado pelo resultado da conta MAX((<express~ ao 2> - <express~ ao 1> + <express~ ao 3>)/<express~ ao 3>,0). Novamente, se o resultado do primeiro argumento da fun c ao MAX acima for negativo, o la co n ao ser a executado. Isto pode acontecer, por exemplo, se <express~ ao 2> for menor que <express~ ao 1> e o passo <express~ ao 3> for positivo. Novamente, se o passo <express~ ao 3> for omitido, este ser a igual a 1. O exemplo abaixo ilustra o uso de express oes no cabe calho do construto: DO I= J + 4, M, -K**2 ... END DO Como se pode ver, o incremento pode ser negativo, o que signica, na pr atica, que os comandos do bloco somente ser ao executados se M <= J + 4. O exemplo a seguir ilustra um bloco DO onde a vari avel I somente assume valores mpares: DO I= 1, 11, 2 ... END DO

Programa 5.2: Exemplo de uso do construto DO.
41
! M o d i f i c a o p a s s o de um l a c o DO d e n t r o do b l o c o . program mod passo i m p l i c i t none integer : : i , j ! Bloco sem m o d i f i c a c a o de p a s s o . do i= 1 , 10 print * , i end do ! Bloco com m o d i f i c a c a o do p a s s o . j= 1 do i= 1 , 1 0 , j i f ( i > 5 ) j= 3 print * , i , j end do end program mod passo
Como no caso do DO rotulado, caso alguma das express oes envolvam o uso de vari aveis, estas podem ser modicadas no bloco do la co, inclusive o passo das itera c oes. Entretanto, o n umero de itera c oes e o passo a ser realmente tomado n ao s ao modicados, uma vez que foram pr e-determinados antes do in cio das itera c oes. O programa abaixo (programa 5.2) exemplica este fato: Abaixo, temos um outro exemplo que ilustra o funcionamento do la co DO: FAT= 1 DO I= 2, N FAT= FAT*I END DO Neste exemplo, o n umero de itera c oes ser a MAX(N-2+1,0) = MAX(N-1,0). Caso N < 2, o la co n ao ser a executado, e o resultado ser a FAT= 1. Caso N >= 2, o valor inicial da vari avel inteira I e 2, esta e usada para calcular um novo valor para a vari avel FAT, em seguida a vari avel I ser a incrementada por 1 e o novo valor I= 3 ser a usado novamente para calcular o novo valor da vari avel FAT. Desta forma, a vari avel I ser a incrementada e o bloco executado at e que I= N + 1, sendo este o u ltimo valor de I e o controle e transferido para o pr oximo comando ap os a declara c ao END DO. O exemplo ilustrado acima retornar a, na vari avel FAT, o valor do fatorial de N. Temos os seguintes casos particulares e instru c oes poss veis para um construto DO.
5.3.1
Construto DO ilimitado
Como caso particular de um construto DO, a seguinte instru c ao e poss vel: [<nome>:] DO <bloco> END DO [<nome>] Neste caso, o conjunto de comandos contidos no <bloco> ser ao realizados sem limite de n umero de itera c oes, exceto se algum teste e inclu do dentro do bloco, o que possibilita um desvio de uxo para a primeira instru c ao ap os o END DO. Uma instru c ao que realiza este tipo de desvio e a instru c ao EXIT, descrita a seguir.
5.3.2
Instru c ao EXIT
Esta instru c ao permite a sa da, por exemplo, de um la co sem limite, mas o seu uso n ao est a restrito a este caso particular, podendo ser usada em um construto DO geral. A forma geral desta instru c ao e: EXIT [<nome>]
42
5.4. Construto CASE
onde o <nome> e opcional, mas deve ser usado caso ele exista e, neste caso, ele serve para denotar de qual construto a sa da deve ser feita. Isto ocorre, por exemplo, no caso de construtos encadeados. Execu c ao de um EXIT transfere controle ao primeiro comando execut avel ap os o END DO [<nome>] correspondente. Como exemplo, temos: DO ... I= I + 1 IF(I == J) EXIT ... END DO
5.3.3
Instru c ao CYCLE
A forma geral desta instru c ao e: CYCLE [<nome>] a qual transfere controle ` a declara c ao END DO do construto correspondente sem ocorrer a execu c ao dos comandos posteriores ` a instru c ao. Assim, se outras itera c oes devem ser realizadas, estas s ao feitas, incrementandose o valor de <vari avel> (caso exista) pelo passo dado pela <express~ ao 3>. O programa a seguir ilustra o uso desta instru c ao. program d o c y c l e i m p l i c i t none integer : : i n d e x= 1 do i n d e x= i n d e x + 1 i f ( i n d e x == 2 0 ) cycle i f ( i n d e x == 3 0 ) exit print * , Valor do n d i c e : , index end do end program d o c y c l e
5.4
Construto CASE
Fortran 90/95 fornece uma outra alternativa para selecionar uma de diversas op c oes: trata-se do construto CASE. A principal diferen ca entre este construto e um bloco IF est a no fato de somente uma express ao ser calculada para decidir o uxo e esta pode ter uma s erie de resultados pr e-denidos. A forma geral do construto CASE e: [<nome>:] SELECT CASE (<express~ ao>) [CASE (<seletor>) [<nome>] <bloco>] ... [CASE DEFAULT <bloco>] END SELECT [<nome>] A <express~ ao> deve ser escalar e pode ser dos tipos inteiro, l ogico ou de caractere e o valor especicado por cada <seletor> deve ser do mesmo tipo. No caso de vari aveis de caracteres, os comprimentos podem diferir, mas n ao a esp ecie. Nos casos de vari aveis inteiras ou l ogicas, a esp ecie pode diferir. A forma mais simples do <seletor> e uma constante entre par enteses, como na declara c ao CASE (1) Para express oes inteiras ou de caracteres, um intervalo pode ser especicado separando os limites inferior e superior por dois pontos : CASE (<inf> : )
43
Um dos limites pode estar ausente, mas n ao ambos. Caso um deles esteja ausente, signica que o bloco de comandos pertencente a esta declara c ao CASE e selecionado cada vez que a <express~ ao> calcula um valor que e menor ou igual a , ou maior ou igual a <inf>, respectivamente. Um exemplo e mostrado abaixo: SELECT CASE CASE (:-1) N_SINAL= CASE (0) N_SINAL= CASE (1:) N_SINAL= END SELECT (NUMERO) -1 ! Somente NUMERO= 0. 0 ! Todos os valores de NUMERO > 0. 1 ! NUMERO e do tipo inteiro. ! Todos os valores de NUMERO menores que 0.
A forma geral do <seletor> e uma lista de valores e de intervalos n ao sobrepostos, todos do mesmo tipo que <express~ ao>, entre par enteses, tal como CASE (1, 2, 7, 10:17, 23) Caso o valor calculado pela <express~ ao> n ao pertencer a nenhuma lista dos seletores, nenhum dos blocos e executado e o controle do uxo passa ao primeiro comando ap os a declara c ao END SELECT. J a a declara c ao CASE DEFAULT e equivalente a uma lista de todos os valores poss veis de <express~ ao> que n ao foram inclu dos nos outros seletores do construto. Portanto, somente pode haver um CASE DEFAULT em um dado construto CASE. O exemplo a seguir ilustra o uso desta declara c ao: SELECT CASE (CH) ! CH e do tipo de caractere. CASE (C, D, R:) CH_TYPE= .TRUE. CASE (I:N) INT_TYPE= .TRUE. CASE DEFAULT REAL_TYPE= .TRUE. END SELECT No exemplo acima, os caracteres C, D, R e todos os caracteres ap os o u ltimo indicam nomes de vari aveis do tipo de caractere. Os caracteres I e N indicam vari aveis do tipo inteiro, e todos os outros caracteres alfab eticos indicam vari aveis reais. O programa-exemplo abaixo mostra o uso deste construto. Note que os seletores de caso somente testam o primeiro caractere da vari avel NOME, embora esta tenha um comprimento igual a 5. program c a s e s t r i n g i m p l i c i t none character ( len= 5 ) : : nome print * , Entre com o nome ( 5 c a r a c t e r e s ) : read ( a5 ) , nome s e l e c t case ( nome ) case ( a : z ) ! S e l e c i o n a nome que come c a com l e t r a s m i n u sculas . print * , P a l a v r a i n i c i a com L e t r a m i n u scula . case ( A : Z ) ! S e l e c i o n a nome que come c a com l e t r a s m a i u sculas . print * , P a l a v r a i n i c i a com l e t r a s m a i u scula . case ( 0 : 9 ) ! S e l e c i o n a n u meros . print * , P a l a v r a i n i c i a com n u meros ! ! ! case default ! Outros t i p o s de c a r a c t e r e s . print * , P a l a v r a i n i c i a com C a r a c t e r e s e s p e c i a i s ! ! ! end s e l e c t end program c a s e s t r i n g J a o programa abaixo, testa o sinal de n umeros inteiros:
44
5.4. Construto CASE
program t e s t a c a s e i m p l i c i t none integer : : a print * , Entre com a ( i n t e i r o ) : read * , a s e l e c t case ( a ) case (: 1) print * , Menor que z e r o . case ( 0 ) print * , I g u a l a z e r o . case ( 1 : ) print * , Maior que z e r o . end s e l e c t end program t e s t a c a s e O programa abaixo ilustra o uso de alguns dos construtos discutidos neste cap tulo. ! Imprime uma t a b e l a de c o n v e r s a o das e s c a l a s C e l s i u s e F a h r e n h e i t ! e n t r e l i m i t e s de t e m p e r a t u r a e s p e c i f i c a d o s . program conv temp i m p l i c i t none character ( len= 1 ) : : s c a l e integer : : low temp , high temp , temp real : : c e l s i u s , f a r e n h e i t ! r e a d l o o p : do ! L e escala e limites . print * , E s c a l a de t e m p e r a t u r a s (C/F ) : read ( a ) , s c a l e ! Confere v a l i d a d e dos dados . i f ( s c a l e /= C . and . s c a l e /= F) then print * , E s c a l a n ao v alida ! e xi t r e a d l o o p end i f print * , L i m i t e s ( temp . i n f e r i o r , temp . s u p e r i o r ) : read * , low temp , high temp ! ! La c o s o b r e os l i m i t e s de t e m p e r a t u r a . do temp= low temp , high temp ! Escolhe f o r m u l a de c o n v e r s ao s e l e c t case ( s c a l e ) case ( C) c e l s i u s= temp f a r e n h e i t= 9 * c e l s i u s / 5 . 0 + 3 2 . 0 case ( F) f a r e n h e i t= temp c e l s i u s= 5 * ( f a r e n h e i t 3 2 ) / 9 . 0 end s e l e c t ! Imprime t a b e l a print * , c e l s i u s , g r a u s C correspondem a , f a r e n h e i t , g r a u s F . end do end do r e a d l o o p ! ! Finaliza c ao . print * , F i n a l dos dados v alidos . end program conv temp
Cap tulo 6
Processamento de Matrizes
A deni c ao e o processamento de matrizes e vetores sempre foi um recurso presente em todas as linguagens de programa c ao, inclusive no Fortran 77. Uma novidade importante introduzida no Fortran 90/95 e a capacidade estendida de processamento das mesmas. Agora e poss vel trabalhar diretamente com a matriz completa, ou com se c oes da mesma, sem ser necess ario o uso de la cos DO. Novas fun c oes intr nsecas agora atuam de forma elemental (em todos os elementos) em matrizes e fun c oes podem retornar valores na forma de matrizes. Tamb em est ao dispon veis as possibilidades de matrizes aloc aveis, matrizes de forma assumida e matrizes din amicas. Estes e outros recursos ser ao abordados neste e nos pr oximos cap tulos.
6.1
Terminologia e especica co es de matrizes
Uma matriz ou vetor 1 e um outro tipo de objeto composto suportado pelo Fortran 77/90/95. Uma matriz consiste de um conjunto retangular de elementos, todos do mesmo tipo e esp ecie do tipo. Uma outra deni c ao equivalente seria: uma matriz e um grupo de posi c oes na mem oria do computador as quais s ao acessadas por interm edio de um u nico nome, fazendo-se uso dos subscritos da matriz. Este tipo de objeto e u til quando for necess ario se fazer refer encia a um n umero grande, por em a princ pio desconhecido, de vari aveis do tipo intr nseco ou outras estruturas, sem que seja necess ario denir um nome para cada vari avel. O Fortran 77/90/95 permite que uma matriz tenha at e sete subscritos, cada um relacionado com uma dimens ao da matriz. As dimens oes de uma matriz podem ser especicadas usando-se tanto o atributo DIMENSION quanto a declara c ao DIMENSION. Os ndices de cada subscrito da matriz s ao constantes ou vari aveis inteiras e, por conven c ao, eles come cam em 1, exceto quando um intervalo distinto de valores e especicado, atrav es do fornecimento de um limite inferior e um limite superior. A declara c ao de matrizes difere ligeiramente entre o Fortran 77 e o Fortran 90/95. Fortran 77. Uma matriz pode ser denida tanto na declara c ao de tipo intr nseco quanto com o uso da declara c ao DIMENSION: INTEGER NMAX INTEGER POINTS(NMAX),MAT_I(50) REAL R_POINTS(0:50),A DIMENSION A(NMAX,50) CHARACTER COLUMN(5)*25, ROW(10)*30 No u ltimo exemplo acima, o vetor COLUMN possui 5 componentes, COLUMN(1), COLUMN(2), ..., COLUMN(5), cada um destes sendo uma vari avel de caractere de comprimento 25. J a o vetor ROW possui 10 componentes, cada um sendo uma vari avel de caractere de comprimento 30. A matriz real A possui 2 dimens oes, sendo NMAX linhas e 50 colunas. Todas as matrizes neste exemplo t em seus ndices iniciando em 1, exceto pela matriz R_POINTS, a qual inicia em 0: R_POINTS(0), R_POINTS(1), ..., R_POINTS(50). Ou seja, este vetor possui 51 componentes.
1 Nome
usualmente para uma matriz de uma dimens ao.
45
46
6.1. Terminologia e especica c oes de matrizes
Fortran 90/95. As formas de declara c oes de matrizes em Fortran 77 s ao aceitas no Fortran 90/95. Por em, e recomend avel que estas sejam declaradas na forma de atributos de tipos de vari aveis. Por exemplo, REAL, DIMENSION(50) :: W REAL, DIMENSION(5:54) :: X CHARACTER(LEN= 25), DIMENSION(5) :: COLUMN CHARACTER(LEN= 30), DIMENSION(10) :: ROW Antes de prosseguir, ser a introduzida a terminologia usada com rela c ao a matrizes. Posto. O posto (rank ) de uma matriz e o n umero de dimens oes da mesma. Assim, um escalar tem posto 0, um vetor tem posto 1 e uma matriz tem posto maior ou igual a 2. Extens ao. A extens ao (extent ) de uma matriz se refere a uma dimens ao em particular e e o n umero de componentes naquela dimens ao. Forma. A forma (shape ) de uma matriz e um vetor cujos componentes s ao a extens ao de cada dimens ao da matriz. Tamanho. O tamanho (size ) de um matriz e o n umero total de elementos que comp oe a mesma. Este n umero pode ser zero, em cujo caso esta se denomina matriz nula. Duas matrizes s ao ditas serem conform aveis se elas t em a mesma forma. Todas as matrizes s ao conform aveis com um escalar, uma vez que o escalar e expandido em uma matriz com a mesma forma (ver se c ao 6.2). Por exemplo, as seguintes matrizes: REAL, DIMENSION(-3:4,7) :: A REAL, DIMENSION(8,2:8) :: B REAL, DIMENSION(8,0:8) :: D INTEGER :: C A matriz A possui:
posto 2; extens oes 8 e 7; forma (/8,7/), onde os s mbolos (/ e /) s ao os construtores de matrizes, isto e, eles denem ou inicializam os valores de um vetor ou matriz. Estes construtores de matrizes ser ao descritos com mais detalhes na se c ao 6.6. Tamanho 56.
Al em disso, A e conform avel com B e C, uma vez que a forma de B tamb em e (/8,7/) e C e um escalar. Contudo, A n ao e conform avel com D, uma vez que esta u ltima tem forma (/8,9/). A forma geral da declara c ao de uma ou mais matrizes e como se segue: <tipo>[[, DIMENSION(<lista de extens~ oes>)] [, < outros atributos>] ::] Entretanto, a forma recomend avel da declara c ao e a seguinte: <tipo>, DIMENSION(<lista de extens~ oes>) [, <outros atributos>] :: <lista de nomes> Onde <tipo> pode ser um tipo intr nseco de vari avel ou de tipo derivado (desde que a deni c ao do tipo derivado esteja acess vel). A <lista de extens~ oes> fornece as dimens oes da matriz atrav es de:
constantes inteiras; express oes inteiras usando vari aveis mudas (dummy ) ou constantes; somente o caractere : para indicar que a matriz e aloc avel ou de forma assumida.
<lista de nomes>
Os <outros atributos> podem ser quaisquer da seguinte lista:

Cap tulo 6. Processamento de Matrizes PARAMETER ALLOCATABLE INTENT(INOUT) OPTIONAL SAVE EXTERNAL INTRINSIC PUBLIC PRIVATE POINTER TARGET
47
Os atributos contidos na lista acima ser ao abordados ao longo deste e dos pr oximos cap tulos. Os atributos em vermelho: POINTER e TARGET consistem em recursos avan cados do Fortran 90/95 que ser ao discutidos em separado. Finalmente, segue a <lista de nomes> v alidos no Fortran, onde os mesmos s ao atribu dos ` as matrizes. Os seguintes exemplos mostram a forma da declara c ao de diversos tipos diferentes de matrizes, alguns dos quais s ao novos no Fortran 90/95 e ser ao abordados adiante. 1. Inicializa c ao de vetores contendo 3 elementos: INTEGER :: I INTEGER, DIMENSION(3) :: IA= (/1,2,3/), IB= (/(I, I=1,3)/) 2. Declara c ao da matriz autom atica LOGB. Aqui, LOGA e uma matriz qualquer (muda ou dummy) e SIZE e uma fun c ao intr nseca que retorna um escalar inteiro correspondente ao tamanho do seu argumento: LOGICAL, DIMENSION(SIZE(LOGA)) :: LOGB 3. Declara c ao das matrizes din amicas, ou aloc aveis, de duas dimens oes A e B. A forma das matrizes ser a denida a posteriori por um comando ALLOCATE: REAL, DIMENSION(:,:), ALLOCATABLE :: A,B 4. Declara c ao das matrizes de forma assumida de tr es dimens oes A e B. A forma das matrizes ser a assumida a partir das informa c oes transferidas pela rotina que aciona o sub-programa onde esta declara c ao e feita. REAL, DIMENSION(:,:,:) :: A,B Matrizes de tipos derivados. A capacidade de se misturar matrizes com deni c oes de tipos derivados possibilita a constru c ao de objetos de complexidade crescente. Alguns exemplos ilustram estas possibilidades. Um tipo derivado pode conter um ou mais componentes que s ao matrizes: TYPE :: TRIPLETO REAL :: U REAL, DIMENSION(3) :: DU REAL, DIMENSION(3,3) :: D2U END TYPE TRIPLETO TYPE(TRIPLETO) :: T Este exemplo serve para declarar, em uma u nica estrutura, um tipo de vari avel denominado TRIPLETO, cujos componentes correspondem ao valor de uma fun c ao de 3 vari aveis, suas 3 derivadas parciais de primeira ordem e suas 9 derivadas parciais de segunda ordem. Se a vari avel T e do tipo TRIPLETO, T%U e um escalar real, mas T%DU e T%D2U s ao matrizes do tipo real. poss E vel agora realizar-se combina c oes entre matrizes e o tipo derivado TRIPLETO para se obter objetos mais complexos. No exemplo abaixo, declara-se um vetor cujos elementos s ao TRIPLETOs de diversas fun c oes distintas: TYPE(TRIPLETO), DIMENSION(10) :: V
48
6.1. Terminologia e especica c oes de matrizes
Assim, a refer encia ao objeto V(2)%U fornece o valor da fun c ao correspondente ao segundo elemento do vetor V; j a a refer encia V(5)%D2U(1,1) fornece o valor da derivada segunda em rela c ao ` a primeira vari avel da fun c ao correspondente ao elemento 5 do vetor V, e assim por diante. O primeiro programa a seguir exemplica um uso simples de matrizes: ! D e c l a r a um v e t o r , d e f i n e v a l o r e s aos e l e m e n t o s do mesmo e imprime ! e s t e s v a l o r e s na t e l a . program e x 1 a r r a y i m p l i c i t none integer , parameter : : dp= s e l e c t e d r e a l k i n d ( 1 0 , 2 0 0 ) integer : : i real , dimension ( 1 0 ) : : vr r e a l ( kind= dp ) , dimension ( 1 0 ) : : vd ! do i= 1 , 1 0 vr ( i )= s q r t ( r e a l ( i ) ) vd ( i )= s q r t ( r e a l ( i ) ) end do print * , Raiz quadrada dos 10 p r i m e i r o s i n t e i r o s , em p r e c i s a o s i m p l e s : print * , vr ! Imprime t o d o s os componentes do v e t o r . print * , print * , Raiz quadrada dos 10 p r i m e i r o s i n t e i r o s , em p r e c i s a o dupla : print * , vd end program e x 1 a r r a y
O segundo programa-exemplo, a seguir, est a baseado no programa alunos, descrito na se c ao 3.8. Agora, ser a criado um vetor para armazenar os dados de um n umero xo de alunos e os resultados somente ser ao impressos ap os a aquisi c ao de todos os dados. ! 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 v e t i m p l i c i t none integer : : i , n d i s c= 5 ! Mude e s t e v a l o r , c a s o s e j a maior . 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 ) , dimension ( 5 ) : : d i s c ! do i= 1 , n d i s c print * , Nome : read ( a ) , d i s c ( i )%nome print * , c odigo : read * , d i s c ( i )% c o d i g o print * , Notas : N1 , N2 , N3 : read * , d i s c ( i )%n1 , d i s c ( i )%n2 , d i s c ( i )%n3 d i s c ( i )%mf= ( d i s c ( i )%n1 + d i s c ( i )%n2 + d i s c ( i )%n3 ) / 3 . 0 end do do i= 1 , n d i s c print * , print * , > , d i s c ( i )%nome , ( , d i s c ( i )%c o d i g o , ) < print * , M e dia f i n a l : , d i s c ( i )%mf end do end program a l u n o s v e t
Cap tulo 6. Processamento de Matrizes
49
6.2
Express oes e atribui co es envolvendo matrizes
Com o Fortran 77 n ao era poss vel desenvolver express oes envolvendo o conjunto de todos os elemento de uma matriz simultaneamente. Ao inv es disso, cada elemento da matriz deveria ser envolvido na express ao separadamente, em um processo que com frequ encia demandava o uso de diversos la cos DO encadeados. Quando a opera c ao envolvia matrizes grandes, com 100 100 elementos ou mais, tais processos podiam ser extremamente dispendiosos do ponto de vista do tempo necess ario para a realiza c ao de todas as opera c oes desejadas, pois os elementos da(s) matriz(es) deveriam ser manipulado de forma seq uencial. Al em disso, o c odigo tornava-se gradualmente mais complexo para ser lido e interpretado, ` a medida que o n umero de opera c oes envolvidas aumentava. Um desenvolvimento novo, introduzido no Fortran 90, e a sua habilidade de realizar opera c oes envolvendo a matriz na sua totalidade, possibilitando o tratamento de uma matriz como um objeto u nico, o que, no m nimo, facilita enormemente a constru c ao, leitura e interpreta c ao do c odigo. Uma outra vantagem, ainda mais importante, resulta deste novo modo de encarar matrizes. Com o desenvolvimento dos processadores e das arquiteturas de computadores, entraram em linha, recentemente, sistemas compostos por mais de um processador, os quais fazem uso da id eia de processamento distribu do ou, em outras palavras, processamento paralelo. As normas denidas pelo comit e X3J3 para o padr ao da linguagem Fortran 90/95 sup oe que compiladores usados em sistemas distribu dos devem se encarregar de distribuir automaticamente os processos num ericos envolvidos nas express oes com matrizes de forma equilibrada entre os diversos processadores que comp oe a arquitetura. A evidente vantagem nesta estrat egia consiste no fato de que as mesmas opera c oes num ericas s ao realizadas de forma simult anea em diversos componentes distintos das matrizes, acelerando substancialmente a eci encia do processamento. Com a losoa das opera c oes sobre matrizes inteiras, a tarefa de implantar a paraleliza c ao do c odigo num erico ca, essencialmente, a cargo do compilador e n ao do programador. Uma outra vantagem deste enfoque consiste na manuten c ao da portabilidade dos c odigos num ericos. Para que as opera c oes envolvendo matrizes inteiras sejam poss veis, e necess ario que as matrizes consideradas sejam conform aveis, ou seja, elas devem todas ter a mesma forma. Opera c oes entre duas matrizes conform aveis s ao realizadas na maneira elemental (distribuindo as opera c oes entre os diversos processadores, se existirem) e todos os operadores num ericos denidos para opera c oes entre escalares tamb em s ao denidos para opera c oes entre matrizes. Por exemplo, sejam A e B duas matrizes 2 3: A= o resultado da adi c ao de A por B e: A+B= o resultado da multiplica c ao e: A*B = e o resultado da divis ao e: A/B = 3/5 2 8 5/3 2 6 . 15 8 8 15 18 6 869 897 , 348 566 , B= 521 331 ,
Se um dos operandos e um escalar, ent ao este e distribu do em uma matriz conform avel com o outro operando. Assim, o resultado de adicionar 5 a A e: A+5= 348 566 + 555 555 = 8 9 13 10 11 11 .
Esta distribui c ao de um escalar em uma matriz conform avel eu til no momento da inicializa c ao dos elementos de uma matriz. Da mesma forma como acontece com express oes e atribui c oes escalares, em uma linha de programa c ao como a seguir, A= A + B sendo A e B matrizes, a express ao do lado direito e desenvolvida antes da atribui c ao do resultado da express ao ` a matriz A. Este ordenamento e importante quando uma matriz aparece em ambos os lados de uma atribui c ao, como no caso do exemplo acima.
50
6.2. Express oes e atribui c oes envolvendo matrizes
As vantagens do processamento de matrizes inteiras, presente no Fortran 90/95 mas ausente no Fortran 77, podem ser contempladas atrav es da compara c ao de alguns exemplos de c odigos desenvolvidos em ambas as revis oes da linguagem. Nestes c odigos ser ao tamb em apresentadas algumas fun c oes intr nsecas do Fortran 90/95 que operam em matrizes, elemento a elemento. Uma descri c ao completa das rotinas intr nsecas e apresentada no cap tulo 7. 1. Considere tr es vetores, A, B e C, todos do mesmo comprimento. Inicialize todos os elementos de A a zero e realize as atribui c oes A(I)= A(I)/3.1 + B(I)*SQRT(C(I)) para todos os valores de I Solu c ao Fortran 77. REAL A(20), B(20), C(20) ... DO 10 I= 1, 20 A(I)= 0.0 CONTINUE DO 20 I= 1, 20 A(I)= A(I)/3.1 + B(I)*SQRT(C(I)) CONTINUE
10 ...
20
Solu c ao Fortran 90/95. REAL, DIMENSION(20) :: A= 0.0, B, C ... A= A/3.1 + B*SQRT(C) Note como o c odigo cou mais reduzido e f acil de ser lido. Al em disso, a fun c ao intr nseca SQRT opera sobre cada elemento do vetor C. 2. Considere tr es matrizes bi-dimensionais com a mesma forma. Multiplique duas matrizes entre si, elemento a elemento, e atribua o resultado a uma terceira matriz. Solu c ao Fortran 77. REAL A(5,5), B(5,5), C(5,5) ... DO 20 I= 1, 5 DO 10 J= 1, 5 C(J,I)= A(J,I) + B(J,I) CONTINUE CONTINUE
10 20
Solu c ao Fortran 90/95. REAL, DIMENSION(5,5) :: A, B, C ... C= A + B 3. Considere uma matriz tri-dimensional. Encontre o maior valor menor que 1000 nesta matriz. Solu c ao Fortran 77. REAL A(5,5,5) REAL VAL_MAX ... 0.0 1, 5 J= 1, 5 10 I= 1, 5 IF((A(I,J,K) .GT. VAL_MAX) .AND. & (A(I,J,K) .LT. 1000.0))VAL_MAX= A(I,J,K) CONTINUE CONTINUE CONTINUE
VAL_MAX= DO 30 K= DO 20 DO
10 20 30
Cap tulo 6. Processamento de Matrizes Solu c ao Fortran 90/95. REAL, DIMENSION(5,5,5) :: A REAL :: VAL_MAX ... VAL_MAX= MAXVAL(A, MASK=(A<1000.0))
51
Note que no Fortran 95 conseguiu-se fazer em uma linha o que necessitou de 8 linhas no Fortran 77. A fun c ao intr nseca MAXVAL devolve o valor m aximo entre os elementos de uma matriz. O argumento opcional MASK=(...) estabelece uma m ascara, isto e, uma express ao l ogica envolvendo a(s) matriz(es). Em MASK=(A<1000.0), somente aqueles elementos de A que satisfazem a condi c ao de ser menores que 1000 s ao levados em considera c ao. 4. Encontre o valor m edio dos elementos maiores que 3000 na matriz A do exemplo anterior. Solu c ao Fortran 77. REAL A(5,5,5) REAL MEDIA,ACUM INTEGER CONTA ... ACUM= 0.0 CONTA= 0 DO 30 K= 1, 5 DO 20 J= 1, 5 DO 10 I= 1, 5 IF(A(I,J,K) .GT. 3000.0)THEN ACUM= ACUM + A(I,J,K) CONTA= CONTA + 1 END IF 10 CONTINUE 20 CONTINUE 30 CONTINUE MEDIA= ACUM/REAL(CONTA) Solu c ao Fortran 90/95. REAL, DIMENSION(5,5,5) :: A REAL :: MEDIA ... MEDIA= SUM(A,MASK=(A>3000.0))/COUNT(MASK=(A>3000.0)) Agora, conseguiu-se realizar em uma linha de c odigo em Fortran 90 o que necessitou de 13 linhas em Fortran 77. Os u ltimos dois exemplos zeram uso das seguintes fun c oes intr nsecas (ver se c ao 7.12): MAXVAL - retorna o valor m aximo de uma matriz. SUM - retorna a soma de todos os elementos de uma matriz. COUNT - retorna o n umero de elementos da matriz que satisfazem a m ascara.
6.3
Se c oes de matrizes
Uma sub-matriz, tamb em chamada se c ao de matriz, pode ser acessada atrav es da especica c ao de um intervalo de valores de subscritos da matriz. Uma se c ao de matriz pode ser acessada e operada da mesma forma que a matriz completa, mas n ao e poss vel fazer-se refer encia direta a elementos individuais ou a subse c oes da se c ao. Se c oes de matrizes podem ser extra das usando-se um dos seguintes artif cios:
Um subscrito simples. Um tripleto de subscritos. Um vetor de subscritos.
Estes recursos ser ao descritos a seguir.

52
6.3. Se c oes de matrizes
6.3.1
Subscritos simples
Um subscrito simples seleciona um u nico elemento da matriz. Considere a seguinte matriz 5 5, denominada RA. Ent ao o elemento X pode ser selecionado atrav es de RA(2,2): 00000 0 X 0 0 0 RA = 0 0 0 0 0 = RA(2, 2) = X. 0 0 0 0 0 00000
6.3.2
Tripleto de subscritos
A forma de um tripleto de subscritos e a seguinte, sendo esta forma geral v alida para todas as dimens oes denidas para a matriz: [<limite inferior>] : [<limite superior>] : [<passo>] Se um dos limites, inferior ou superior (ou ambos) for omitido, ent ao o limite ausente e assumido como o limite inferior ou superior da correspondente dimens ao da matriz da qual a se c ao est a sendo extra da; se o <passo> for omitido, ent ao assume-se <passo>=1. Os exemplos a seguir ilustram v arias se c oes de matrizes usando-se tripletos. Os elementos das matrizes marcados por X denotam a se c ao a ser extra da. Novamente, no exemplo ser a utilizada a matriz 5 5 denominada RA. 00000 0 X 0 0 0 RA = 0 0 0 0 0 =RA(2:2,2:2) = X; Elemento simples, escalar, forma: (/1/). 0 0 0 0 0 00000 00000 0 0 0 0 0 RA = c ao de linha da matriz, forma: (/3/). 0 0 X X X =RA(3,3:5); se 0 0 0 0 0 00000 00X00 0 0 X 0 0 RA = 0 0 X 0 0 =RA(:,3); coluna inteira, forma: (/5/). 0 0 X 0 0 00X00 0XXX0 0 0 0 0 0 RA = c oes de linhas com passo 2, forma: (/3,3/). 0 X X X 0 =RA(1::2,2:4); se 0 0 0 0 0 0XXX0
6.3.3
Vetores de subscritos
Um vetor de subscritos e uma express ao inteira de posto 1, isto e, um vetor. Cada elemento desta express ao deve ser denido com valores que se encontrem dentro dos limites dos subscritos da matriz-m ae. Os elementos de um vetor de subscritos podem estar em qualquer ordem. Um exemplo ilustrando o uso de um vetor de subscritos, denominado IV, e dado a seguir: REAL, DIMENSION(6) :: REAL, DIMENSION(3) :: INTEGER, DIMENSION(3) RB= RA(IV) ! IV e o RA= (/ 1.2, 3.4, 3.0, 11.2, 1.0, 3.7 /) RB :: IV= (/ 1, 3, 5 /) ! Express~ ao inteira de posto 1. vetor de subscritos.
Cap tulo 6. Processamento de Matrizes ! Resulta: !RB= (/ RA(1), RA(3), RA(5) /), ou !RB= (/ 1.2, 3.0, 1.0 /). Um vetor de subscritos pode tamb em estar do lado esquerdo de uma atribui c ao: IV= (/ 1, 3, 5 /) RA(IV)= (/ 1.2, 3.4, 5.6 /) !Atribui c~ oes dos elementos 1, 3 e 5 de RA. ! Resulta: ! RA(1)= 1.2; RA(3)= 3.4; RA(5)= 5.6 ! Os elementos 2, 4 e 6 de RA n~ ao foram definidos.
53
6.4
Atribui co es de matrizes e sub-matrizes
Tanto matrizes inteiras quanto se c oes de matrizes podem ser usadas como operandos (isto e, podem estar tanto no lado esquerdo quanto do lado direito de uma atribui c ao) desde que todos os operandos sejam conform aveis (p agina 46). Por exemplo, REAL, DIMENSION(5,5) :: RA, RB, RC INTEGER :: ID ... RA= RB + RC*ID !Forma (/5,5/). ... RA(3:5,3:4)= RB(1::2,3:5:2) + RC(1:3,1:2) !Forma (/3,2/): !RA(3,3)= RB(1,3) + RC(1,1) !RA(4,3)= RB(3,3) + RC(2,1) !RA(5,3)= RB(5,3) + RC(3,1) !RA(3,4)= RB(1,5) + RC(1,2) !etc. ... RA(:,1)= RB(:,1) + RB(:,2) + RC(:3) !Forma (/5/). Um outro exemplo, acompanhado de gura, torna a opera c ao com sub-matrizes conform aveis mais clara. REAL, DIMENSION(10,20) :: A,B REAL, DIMENSION(8,6) :: C ... C= A(2:9,5:10) + B(1:8,15:20) !Forma (/8,6/). ... A gura 6.1 ilustra como as duas sub-matrizes s ao conform aveis neste caso e o resultado da soma das duas se c oes ser a atribu do ` a matriz C, a qual possui a mesma forma. O programa-exemplo 6.1 mostra algumas opera c oes e atribui c oes b asicas de matrizes:
6.5
Matrizes de tamanho zero
Matrizes de tamanho zero, ou matrizes nulas tamb em s ao permitidas em Fortran 90/95. A no c ao de uma matriz nula eu til quando se quer contar com a possibilidade de exist encia de uma matriz sem nenhum elemento, o que pode simplicar a programa c ao do c odigo em certas situa c oes. Uma matriz e nula quando o limite inferior de uma ou mais de suas dimens oes e maior que o limite superior. Por exemplo, o c odigo abaixo resolve um sistema linear de equa c oes que j a est ao na forma triangular: DO I= 1, N X(I)= B(I)/A(I,I) B(I+1:N)= B(I+1:N) - A(I+1:N,I)*X(I) END DO
54
A(1,1) A(2,5)
6.5. Matrizes de tamanho zero

A(1,20) A(2,10)
A(9,5)
A(9,10) A(20,20) + = B(1,15) B(1,20)
Resultado 8x6
A(10,1) B(1,1)
B(8,15)
B(10,1)
B(20,20)
Figura 6.1: A soma de duas se co es de matrizes conform aveis.
Quando I assume o valor N, as sub-matrizes B(N+1:N) e A(N+1:N,N) se tornam nulas. Se esta possibilidade n ao existisse, seria necess aria a inclus ao de linhas adicionais de programa c ao. As matrizes nulas seguem as mesmas regras de opera c ao e atribui c ao que as matrizes usuais, por em elas ainda devem ser conform aveis com as matrizes restantes. Por exemplo, duas matrizes nulas podem ter o mesmo posto mas formas distintas; as formas podem ser (/2,0/) e (/0,2/). Neste caso, estas matrizes n ao s ao conform aveis. Contudo, uma matriz e sempre conform avel com um escalar, assim a atribui c ao
Programa 6.1: Express oes e atribui co es envolvendo matrizes.
program t e s t a a t r m a t r i m p l i c i t none real , dimension ( 3 , 3 ) : : a real , dimension ( 2 , 2 ) : : b integer : : i , j ! do i= 1 , 3 do j= 1 , 3 a ( i , j )= s i n ( r e a l ( i ) ) + c o s ( r e a l ( j ) ) end do end do b= a ( 1 : 2 , 1 : 3 : 2 ) print * , Matriz A: print ( 3 ( f 1 2 . 5 ) ) , ( ( a ( i , j ) , j= 1 , 3 ) , i= 1 , 3 ) Print * , Matriz B : print ( 2 ( f 1 2 . 5 ) ) , ( ( b ( i , j ) , j= 1 , 2 ) , i= 1 , 2 ) end program t e s t a a t r m a t r
Cap tulo 6. Processamento de Matrizes <matriz nula>= <escalar> e sempre v alida.
55
6.6
Construtores de matrizes
Um construtor de matrizes cria um vetor (matriz de posto 1) contendo valores constantes. Estes construtores servem, por exemplo, para inicializar os elementos de um vetor, como foi exemplicado na p agina 47. Outro exemplo de uso dos construtores de matrizes est a na deni c ao de um vetor de subscritos, como foi abordado na se c ao 6.3.3. A forma geral de um construtor de matrizes e a seguinte: (/ <lista de valores do construtor> /) onde <lista de valores do construtor> pode ser tanto uma lista de constantes, como no exemplo IV= (/ 1, 3, 5 /) como pode ser um conjunto de express oes num ericas: A= (/ I+J, 2*I, 2*J, I**2, J**2, SIN(REAL(I)), COS(REAL(J)) /) ou ainda um comando DO impl cito no construtor, cuja forma geral e a seguinte: (<lista de valores do construtor>, <vari avel>= <exp1>, <exp2>, [<exp3>]) onde <vari avel> e uma vari avel escalar inteira e <exp1>, <exp2> e <exp3> s ao express oes escalares inteiras. A interpreta c ao dada a este DO impl cito e que a <lista de valores dos construtor> e escrita um n umero de vezes igual a MAX((<exp2> - <exp1> + <exp3>)/<exp3>, 0) sendo a <vari avel> substitu da por <exp1>, <exp1> + <exp3>, ..., <exp2>, como acontece no construto DO (se c ao 5.3). Tamb em e poss vel encadear-se DOs impl citos. A seguir, alguns exemplos s ao apresentados: (/ (i, i= 1,6) /) ! Resulta: (/ 1, 2, 3, 4, 5, 6 /)
(/ 7, (i, i= 1,4), 9 /) ! Resulta: (/ 7, 1, 2, 3, 4, 9 /)
(/ (1.0/REAL(I), I= 1,6) /) ! Resulta: (/ 1.0/1.0, 1.0/2.0, 1.0/3.0, 1.0/4.0, 1.0/5.0, 1.0/6.0 /)
! DOs impl citos encadeados: (/ ((I, I= 1,3), J= 1,3) /) ! Resulta: (/ 1, 2, 3, 1, 2, 3, 1, 2, 3 /)
(/ ((I+J, I= 1,3), J= 1,2) /) ! = (/ ((1+J, 2+J, 3+J), J= 1,2) /) ! Resulta: (/ 2, 3, 4, 3, 4, 5 /) Um construtor de matrizes pode tamb em ser criado usando-se tripletos de subscritos: (/ A(I,2:4), A(1:5:2,I+3) /) ! Resulta: (/ A(I,2), A(I,3), A(I,4), A(1,I+3), A(3,I+3), A(5,I+3) /)
56
6.6. Construtores de matrizes
B(1,1) B(2,1) B(3,1) B(4,1) B(5,1)
B(1,1) B(2,2) B(3,2) B(4,2) B(5,2)
B(1,3) B(2,3) B(3,3) B(4,3) B(5,3)
B(1,4) B(2,4) B(3,4) B(4,4) B(5,4)
Figura 6.2: O ordenamento dos elementos da matriz B(5,4).
6.6.1
A fun c ao intr nseca RESHAPE.
Uma matriz de posto maior que um pode ser constru da a partir de um construtor de matrizes atrav es do uso da fun c ao intr nseca RESHAPE. Por exemplo, RESHAPE( SOURCE= (/ 1, 2, 3, 4, 5, 6 /), SHAPE= (/ 2, 3 /) ) gera a matriz de posto 2: 135 246 a qual e uma matriz de forma (/ 2, 3 /), isto e, 2 linhas e 3 colunas. Um outro exemplo seria: REAL, DIMENSION(3,2) :: RA RA= RESHAPE( SOURCE= (/ ((I+J, I= 1,3), J= 1,2) /), SHAPE= (/ 3,2 /) ) de onde resulta 23 RA = 3 4 45
Usando a fun c ao RESHAPE, o programa-exemplo da p agina 53 apresenta uma forma mais concisa: program t e s t a a t r m a t r i m p l i c i t none real , dimension ( 3 , 3 ) : : a real , dimension ( 2 , 2 ) : : b integer : : i , j ! a= r e s h a p e ( s o u r c e= ( / ( ( s i n ( r e a l ( i ))+ c o s ( r e a l ( j ) ) , i= 1 , 3 ) , j= 1 , 3 ) / ) , & shape= ( / 3 , 3 / ) ) b= a ( 1 : 2 , 1 : 3 : 2 ) print * , Matriz A: print ( 3 ( f 1 2 . 5 ) ) , ( ( a ( i , j ) , j= 1 , 3 ) , i= 1 , 3 ) Print * , Matriz B : print ( 2 ( f 1 2 . 5 ) ) , ( ( b ( i , j ) , j= 1 , 2 ) , i= 1 , 2 ) end program t e s t a a t r m a t r
6.6.2
A ordem dos elementos de matrizes
A maneira como a fun c ao RESHAPE organizou os elementos das matrizes na se c ao 6.6.1 seguiu a denominada ordem dos elementos de matriz, a qual e a maneira como a maioria dos compiladores de Fortran armazena os elementos de matrizes em espa cos cont guos de mem oria. Este ordenamento e obtido variandose inicialmente o ndice da primeira dimens ao da matriz, depois variando-se o ndice da segunda dimens ao e assim por diante. Em uma matriz com 2 dimens oes isto e obtido variando-se inicialmente as linhas e depois as colunas. A gura 6.2 ilustra este procedimento com a matriz B(5,4). Em uma matriz com mais de 2 dimens oes, o ordenamento e realizado da mesma maneira. Assim, dada a matriz
Cap tulo 6. Processamento de Matrizes REAL, DIMENSION(-10:5, -20:1, 0:1, -1:0, 2, 2, 2) :: G o ordenamento segue a ordem: G(-10,-20,0,-1,1,1,1) G(-10,-19,0,-1,1,1,1) G(-10,-18,0,-1,1,1,1) G(-10,1,1,0,2,2,2) G(-9,-20,0,-1,1,1,1) G(-9,-19,0,-1,1,1,1) ... G(-9,1,1,0,2,2,2) G(-8,-20,0,-1,1,1,1) G(-8,-19,0,-1,1,1,1) G(-8,-15,0,-1,1,1,1) ... ... G(5,-20,0,-1,1,1,1) ... G(5,-19,0,-1,1,1,1) ... G(5,1,1,0,2,2,1) ... G(5,1,1,0,2,2,2)
57
Em muitas situa c oes, e mais r apido escrever-se um c odigo que processa matrizes seguindo o ordenamento dos elementos. As fun c oes intr nsecas do Fortran 90/95 que manipulam matrizes inteiras foram concebidas de forma a levar em conta este fato.
6.7
Rotinas intr nsecas elementais aplic aveis a matrizes
O Fortran 90/95 permite a exist encia de rotinas (fun c oes ou subrotinas) intr nsecas elementais, isto e, rotinas que se aplicam a cada elemento de uma matriz. Matrizes podem, ent ao, ser usadas como argumentos de rotinas intr nsecas, da mesma forma que escalares. Este tipo de recurso n ao existem no Fortran 77. As opera c oes denidas na rotina intr nseca ser ao aplicadas a cada elemento da matriz separadamente. Novamente, caso mais de uma matriz apare ca no argumento da rotina, estas devem ser conform aveis. A seguir, alguns exemplos de rotinas intr nsecas elementais. A lista completa destas rotinas pode ser obtida no cap tulo 7. 1. Calcule as ra zes quadradas de todos os elementos da matriz A. O resultado ser a atribu do ` a matriz B, a qual e conform avel com A. REAL, DIMENSION(10,10) :: A, B ... B= SQRT(A) 2. Calcule a exponencial de todos os argumentos da matriz A. Novamente, o resultado ser a atribu do a B. COMPLEX, DIMENSION(5,-5:15, 25:125) :: A, B ... B= EXP(A) 3. Encontre o comprimento da string (vari avel de caractere) excluindo brancos no nal da vari avel para todos os elementos da matriz CH. CHARACTER(LEN= 80), DIMENSION(10) :: CH INTEGER :: COMP ... COMP= LEN_TRIM(CH)
6.8
Comando e construto WHERE
Em muitas situa c oes, e desej avel realizar-se opera c oes somente para alguns elementos de uma matriz; por exemplo, somente para aqueles elementos que s ao positivos.
6.8.1
Comando WHERE
O comando WHERE fornece esta possibilidade. Um exemplo simples e: REAL, DIMENSION(10,10) :: A ... WHERE (A > 0.0) A= 1.0/A o qual fornece a rec proca (inversa) de todos os elementos positivos de A, deixando os demais inalterados. A forma geral do comando e
58
6.8. Comando e construto WHERE WHERE (<express~ ao l ogica matriz>) <vari avel matriz>= <express~ ao matriz>
A <express~ ao l ogica matriz> deve ter a mesma forma que a <vari avel matriz>. A express ao l ogica e desenvolvida inicialmente e ent ao somente aqueles elementos da <vari avel matriz> que satisfazem o teste l ogico s ao operados pela <express~ ao matriz>. Os restantes permanecem inalterados.
6.8.2
Construto WHERE
Uma u nica express ao l ogica de matriz pode ser usada para determinar uma seq u encia de opera c oes e atribui c oes em matrizes, todas com a mesma forma. A sintaxe deste construto e: WHERE (<express~ ao l ogica matriz>) <opera c~ oes atribui c~ oes matrizes> END WHERE Inicialmente, a <express~ ao l ogica matriz> e desenvolvida em cada elemento da matriz, resultando em uma matriz l ogica tempor aria, cujos elementos s ao os resultados da <express~ ao l ogica matriz>. Ent ao, cada opera c ao e atribui c ao de matriz no bloco do construto e executada sob o controle da m ascara determinada pela matriz l ogica tempor aria; isto e, as <opera c~ oes atribui c~ oes matrizes> ser ao realizadas em cada elemento das matrizes do bloco que corresponda ao valor .TRUE. da matriz l ogica tempor aria. Existe tamb em uma forma mais geral do construto WHERE que permite a execu c ao de atribui c oes a elementos de matrizes que n ao satisfazem o teste l ogico no cabe calho: WHERE (<express~ ao l ogica matriz>) <opera c~ oes atribui c~ oes matrizes 1> ELSEWHERE <opera c~ oes atribui c~ oes matrizes 2> END WHERE O bloco <opera c~ oes atribui c~ oes matrizes 1> e executado novamente sob o controle da m ascara denida na <express~ ao l ogica matriz> e somente elementos que satisfazem esta m ascara s ao afetados. Em seguida, as <opera c~ oes atribui c~ oes matrizes 2> s ao executadas sob o controle da m ascara denida por .NOT. <express~ ao l ogica matriz>, isto e, novas atribui c oes s ao realizadas sobre elementos que n ao satisfazem o teste l ogico denido no cabe calho. Um exemplo simples do construto WHERE e: WHERE (PRESSURE <= 1.0) PRESSURE= PRESSURE + INC_PRESSURE TEMP= TEMP + 5.0 ELSEWHERE RAINING= .TRUE. END WHERE Neste exemplo, PRESSURE, INC_PRESSURE, TEMP e RAINING s ao todas matrizes com a mesma forma, embora n ao do mesmo tipo. O programa-exemplo 6.2 mostra outra aplica c ao do construto WHERE. Um recurso ausente no Fortran 90 mas incorporado no Fortran 95 e o mascaramento na instru c ao ELSEWHERE, juntamente com a possibilidade de conter qualquer n umero de instru c oes ELSEWHERE mascaradas mas, no m aximo, uma instru c ao ELSEWHERE sem m ascara, a qual deve ser a u ltima. Todas as express oes l ogicas que denem as m ascaras devem ter a mesma forma. Adicionalmente, os construtos WHERE podem ser encadeados e nomeados; neste caso, as condi co es l ogicas de todas as m ascaras devem ter a mesma forma. O seguinte exemplo ilustra este recurso: ATRIB1: WHERE (<cond 1>) <corpo 1> !Mascarado por <cond 1> ELSEWHERE (<cond 2>) ATRIB1 <corpo 2> !Masc. por <cond 2> .AND. .NOT. <cond 1> ATRIB2: WHERE (<cond 4>) <corpo 4> !Masc. por <cond 2> .AND. .NOT. <cond 1> .AND. <cond 4> ELSEWHERE ATRIB2

Programa 6.2: Exemplo do construto WHERE.
59
program t e s t a w h e r e i m p l i c i t none real , dimension ( 3 , 3 ) : : a integer : : i , j ! a= r e s h a p e ( s o u r c e= ( / ( ( s i n ( r e a l ( i+j ) ) , i= 1 , 3 ) , j= 1 , 3 ) / ) , shape= ( / 3 , 3 / ) ) print * , Matriz A o r i g i n a l : print * , a ( 1 , : ) print * , a ( 2 , : ) print * , a ( 3 , : ) ! where ( a >= 0 . 0 ) a= s q r t ( a ) elsewhere a= a ** 2 end where print * , Matriz A m o d i f i c a d a : print * , a ( 1 , : ) print * , a ( 2 , : ) print * , a ( 3 , : ) end program t e s t a w h e r e
<corpo 5> !Masc. por ... ! .AND. END WHERE ATRIB2 ... ELSEWHERE (<cond 3>) ATRIB1 <corpo 3> !Masc. por ... ! .AND. ELSEWHERE ATRIB1 <corpo 6> !Masc. por ... ! .AND. END WHERE ATRIB1
<cond 2> .AND. .NOT. <cond 1> .NOT. <cond 4>
<cond 3> .AND. .NOT. <cond 1> .NOT. <cond 2> .NOT. <cond 1> .AND. .NOT. <cond 2> .NOT. <cond 3>
6.9
Matrizes aloc aveis
Uma novidade importante introduzida no Fortran 90/95 e a habilidade de se declarar vari aveis din amicas; em particular, matrizes din amicas. Fortran 90 fornece tanto matrizes aloc aveis quanto matrizes autom aticas, ambos os tipos sendo matrizes din amicas. Usando matrizes aloc aveis, e poss vel alocar e de-alocar espa co de mem oria conforme necess ario. O recurso de matrizes autom aticas permite que matrizes locais em uma fun c ao ou subrotina tenham forma e tamanho diferentes cada vez que a rotina e invocada. Matrizes autom aticas s ao discutidas no cap tulo 8. Matrizes aloc aveis permitem que grandes fra c oes da mem oria do computador sejam usadas somente quando requerido e, posteriormente, liberadas, quando n ao mais necess arias. Este recurso oferece um uso de mem oria muito mais eciente que o Fortran 77, o qual oferecia somente aloca c ao est atica (xa) de mem oria. Al em disso, o c odigo torna-se muito mais robusto, pois a forma e o tamanho das matrizes podem ser decididos durante o processamento do c odigo. Uma matriz aloc avel e declarada na linha de declara c ao de tipo de vari avel com o atributo ALLOCATABLE. O posto da matriz deve tamb em ser declarado com a inclus ao dos s mbolos de dois pontos :, um para cada dimens ao da matriz. Por exemplo, a matriz de duas dimens oes A e declarada como aloc avel atrav es da declara c ao: REAL, DIMENSION(:,:), ALLOCATABLE :: A Esta forma de declara c ao n ao aloca espa co de mem oria imediatamente ` a matriz, como acontece com as declara c oes usuais de matrizes. O status da matriz nesta situa c ao e not currently allocated, isto e, correnAutor: Rudi Gaelzer IFM/UFPel Impresso: 13 de abril de 2010
60
6.9. Matrizes aloc aveis
temente n ao alocada. Espa co de mem oria e dinamicamente alocado durante a execu c ao do programa, logo antes da matriz ser utilizada, usando-se o comando ALLOCATE. Este comando especica os limites da matriz, seguindo as mesmas regras denidas na se c ao 6.1. A seguir s ao dados dois exemplos de uso deste comando: ALLOCATE (A(0:N,M)) ou usando express oes inteiras: ALLOCATE (A(0:N+1,M)) Como se pode ver, esta estrat egia confere uma exibilidade grande na deni c ao de matrizes ao programador. O espa co alocado ` a matriz com o comando ALLOCATE pode, mais tarde, ser liberado com o comando DEALLOCATE. Este comando requer somente nome da matriz previamente alocada. Por exemplo, para liberar o espa co na mem oria reservado para a matriz A, o comando ca DEALLOCATE (A) Tanto os comandos ALLOCATE e DEALLOCATE possuem o especicador opcional STAT, o qual retorna o status do comando de aloca c ao ou de-aloca c ao. Neste caso, a forma geral do comando e: ALLOCATE (<lista de objetos alocados> [, STAT= <status>]) DEALLOCATE (<lista de objetos alocados> [, STAT= <status>]) onde <status> e uma vari avel inteira escalar. Se STAT= est a presente no comando, <status> recebe o valor zero se o procedimento do comando ALLOCATE/DEALLOCATE foi bem sucedido ou um valor positivo se houve um erro no processo. Se o especicador STAT= n ao estiver presente e ocorra um erro no processo, o programa e abortado. Finalmente, e poss vel alocar-se ou de-alocar-se mais de uma matriz simultaneamente, como indica a <lista de objetos alocados>. Um breve exemplo do uso destes comandos seria: REAL, DIMENSION(:), ALLOCATABLE :: A, B REAL, DIMENSION(:,:), ALLOCATABLE :: C INTEGER :: N ... ALLOCATE (A(N), B(2*N), C(N,2*N)) B(:N)= A B(N+1:)= SQRT(A) DO I= 1,N C(I,:)= B END DO DEALLOCATE (A, B, C) Matrizes aloc aveis tornam poss vel o requerimento freq uente de declarar uma matriz tendo um n umero vari avel de elementos. Por exemplo, pode ser necess ario ler vari aveis, digamos tam1 e tam2 e ent ao declarar uma matriz com tam1 tam2 elementos: INTEGER :: TAM1, TAM2 REAL, DIMENSION (:,:), ALLOCATABLE :: A INTEGER :: STATUS ... READ*, TAM1, TAM2 ALLOCATE (A(TAM1,TAM2), STAT= STATUS) IF (STATUS > 0)THEN ... ! Comandos de processamento de erro. END IF ... ! Uso da matriz A. DEALLOCATE (A) ... No exemplo acima, o uso do especicador STAT= permite que se tome provid encias caso n ao seja poss vel alocar a matriz, por alguma raz ao.
61
Como foi mencionado anteriormente, uma matriz aloc avel possui um status de aloca c ao. Quando a matriz e declarada, mas ainda n ao alocada, o seu status e unallocated ou not currently allocated. Quando a matriz aparece no comando ALLOCATE, o seu status passa a allocated ; uma vez que ela e de-alocada, o seu status retorna a not currently allocated. Assim, o comando ALLOCATE somente pode ser usado em matrizes n ao correntemente alocadas, ao passo que o comando DEALLOCATE somente pode ser usado em matrizes alocadas; caso contr ario, ocorre um erro. poss E vel vericar se uma matriz est a ou n ao correntemente alocada usando-se a fun c ao intr nseca ALLOCATED. Esta e uma fun c ao l ogica com um argumento, o qual deve ser o nome de uma matriz aloc avel. Usando-se esta fun c ao, comandos como os seguintes s ao poss veis: IF (ALLOCATED(A)) DEALLOCATE (A) ou IF (.NOT. ALLOCATED(A)) ALLOCATE (A(5,20)) Um terceiro status de aloca c ao, poss vel no Fortran 90 mas n ao no Fortran 95, e o undened, o qual ocorria quando uma matriz era alocada dentro de uma rotina e n ao era de-alocada antes de retornar ao programa que chamou a rotina. O que ocorria era que em subseq uentes chamadas desta rotina a matriz com o status undened n ao mais podia ser utilizada. No Fortran 95, todas as matrizes aloc aveis denidas em rotinas s ao automaticamente colocadas no status unallocated quando da sa da da rotina. Contudo, um boa pr atica de programa c ao consiste em sempre de-alocar todas as matrizes alocadas dentro de uma rotina. Finalmente, h a tr es restri c oes no uso de matrizes aloc aveis: 1. Matrizes aloc aveis n ao podem ser argumentos mudos de uma rotina e devem, portanto, ser alocadas e de-alocadas dentro da mesma unidade de programa (ver cap tulo 8). 2. O resultado de uma fun c ao n ao pode ser uma matriz aloc avel (embora possa ser uma matriz). 3. Matrizes aloc aveis n ao podem ser usadas na deni c ao de um tipo derivado (esta restri c ao foi retirada no Fortran 2003. O programa-exemplo a seguir ilustra o uso de matrizes aloc aveis. program t e s t a a l o c i m p l i c i t none integer , dimension ( : , : ) , a l l o c a t a b l e : : b integer : : i , j , n= 2 ! print * , Valor i n i c i a l de n : , n allocate (b(n , n )) b= n print * , Valor i n i c i a l de B : print ( 2 ( i 2 ) ) , ( ( b ( i , j ) , j= 1 , n ) , i= 1 , n ) deallocate ( b ) n= n + 1 print * , Segundo v a l o r de n : , n allocate (b(n , n )) b= n print * , Segundo v a l o r de B : print ( 3 ( i 2 ) ) , ( ( b ( i , j ) , j= 1 , n ) , i= 1 , n ) deallocate ( b ) n= n + 1 print * , T e r c e i r o v a l o r de n : , n a l l o c a t e ( b ( n+1,n+1)) b= n + 1 print * , T e r c e i r o v a l o r de B : print ( 5 ( i 2 ) ) , ( ( b ( i , j ) , j= 1 , n+1) , i= 1 , n+1) end program t e s t a a l o c
62
6.10. Comando e construto FORALL
6.10
Comando e construto FORALL
Quando um construto DO como o seguinte: DO I= 1, N A(I,I)= X(I) END DO
!A tem posto 2 e X tem posto 1.
e executado, o processador deve realizar cada itera c ao sucessiva em ordem, com uma atribui c ao ap os a outra. Isto representa um impedimento severo na otimiza c ao do c odigo em uma plataforma paralelizada. Este problema foi enfocado com a constru ca o do HPF (High Performance Fortran ), o qual consiste em uma vers ao do Fortran 90 destinada a sistemas de computa c ao paralela. Posteriormente, alguns avan cos realizados pelo HPF, em rela c ao ao Fortran 90, foram incorporados do padr ao do Fortran 95; entre eles, a instru c ao FORALL. A id eia e oferecer ao programador uma estrutura que possibilite os mesmos recursos obtidos com la cos DO, por em que sejam automaticamente paraleliz aveis, quando o programa estiver rodando em uma plataforma paralela.
6.10.1
Comando FORALL
As instru c oes do exemplo acima s ao implementadas atrav es de um comando FORALL da seguinte maneira: FORALL (I= 1:N) A(I,I)= X(I) a qual especica que as atribui c oes individuais sejam realizadas em qualquer ordem, inclusive simultaneamente, caso o programa rode em uma plataforma paralela. O comando FORALL pode ser visto como uma atribui c ao de matrizes expressa com a ajuda de ndices. Neste exemplo em particular, deve-se notar que as atribui c oes n ao poderiam ser representadas de maneira simples atrav es de uma atribui c ao de matrizes inteiras, tal como A= X, porque as matrizes A e X n ao t em a mesma forma. Outros exemplos do comando s ao: FORALL (I= 1:N, J= 1:M) A(I,J)= I + J FORALL (I= 1:N, J= 1:N, Y(I,J) /= 0.0) X(J,I)= 1.0/Y(I,J) O primeiro exemplo poderia ser implementado com o uso da fun c ao intr nseca RESHAPE, mas o uso do FORALL possibilita a paraleliza c ao do programa execut avel. J a o segundo exemplo n ao poderia ser implementado com opera c ao de matriz inteira (tal como X= 1.0/Y) porque, em primeiro lugar, a matriz X t em elementos transpostos em rela c ao ` a matriz Y. Em segundo lugar, a m ascara Y(I,J) /= 0.0 n ao est a presente na opera c ao de matriz inteira; somente e poss vel introduzir esta m ascara com o uso do FORALL. A forma geral do comando FORALL e a seguinte: FORALL (< ndice>= <menor>:<maior>[:<passo>] [,< ndice>= <menor>:<maior>[:<passo>]] & [...] [, <express~ ao escalar l ogica>]) <opera c~ oes atribui c~ oes matrizes> as condi c oes impostas a < ndice>, <menor>, <maior>, <passo> e <express~ ao escalar l ogica> s ao as mesmas impostas ao construto FORALL e ser ao explicadas na descri c ao da forma geral do mesmo.
6.10.2
Construto FORALL
O construto FORALL tamb em existe. Ele permite que diversas atribui c oes sejam executadas em ordem. Por exemplo, dadas as seguintes opera c oes com sub-matrizes: A(2:N-1, 2:N-1)= A(2:N-1, 1:N-2) + A(2:N-1, 3:N) & + A(1:N-2, 2:N-1) + A(3:N, 2:N-1) B(2:N-1, 2:N-1)= A(2:N-1, 2:N-1) tamb em podem ser implementadas com o uso do construto FORALL: FORALL (I= 2:N-1, J= 2:N-1) A(I,J)= A(I,J-1) + A(I, J+1) + A(I-1, J) + A(I+1, J) B(I,J)= A(I,J) END FORALL
63
Neste exemplo, cada elemento de A e igualado ` a soma dos quatro vizinhos mais pr oximos e e feita ent ao uma c opia em B. A vers ao com o FORALL e melhor leg vel e pode ser executado em qualquer ordem, inclusive simultaneamente. Devido a isto, quando o corpo do construto possui mais de uma instru c ao, o processador executa todas express oes e atribui c oes da primeira linha antes de passar a executar a instru c ao da linha seguinte. N ao ocorre erro na atribui c ao, porque inicialmente as express oes s ao desenvolvidas, em qualquer ordem, seus resultados guardados em local de armazenagem tempor aria na mem oria e s o no nal as atribui c oes s ao feitas, tamb em em qualquer ordem. Construtos FORALL podem ser encadeados. A seq u encia FORALL (I= 1:N-1) FORALL (J= I+1:N) A(I,J)= A(J,I) END FORALL END FORALL atribui a transposta do tri angulo inferior de A ao tri angulo superior de A. Um construto FORALL pode conter um comando ou construto WHERE. Cada comando no corpo de um construto WHERE e executado em seq u encia. Por exemplo, FORALL (I= 1:N) WHERE (A(I,:) == 0) A(I,:)= I B(I,:)= I/A(I,:) END FORALL Aqui, cada elemento nulo de A e substitu do pelo valor do ndice das linhas e, seguindo a opera c ao completa, os elementos das linhas de B s ao denidos como as rec procas dos correspondentes elementos de A multiplicados pelo respectivo ndice. A sintaxe mais geral do construto FORALL e: [<nome>:] FORALL (< ndice>= <menor>:<maior>[:<passo>], & [, < ndice>= <menor>:<maior>[:<passo>]] [...] & [, <express~ ao l ogica escalar>]) <corpo> END FORALL [<nome>] onde < ndice> e uma vari avel inteira escalar, a qual permanece v alida somente dentro do <corpo> do construto, ou seja, outras vari aveis podem ter o mesmo nome do < ndice> mas est ao separadas e n ao s ao acess veis de dentro do FORALL.2 O < ndice> n ao pode ser redenido dentro do construto. As express oes <menor>, <maior> e <passo> devem ser express oes escalares inteiras e formar uma seq u encia de valores como para uma se c ao de matriz (se c ao 6.3); eles n ao podem fazer refer encia a um ndice no mesmo cabe calho, mas podem fazer refer encia a um ndice de um FORALL mais externo. Uma vez tendo as express oes inteiras sido desenvolvidas, a <express~ ao l ogica escalar>, se presente, e desenvolvida para cada combina c ao dos valores dos ndices. Aqueles para os quais o resultado e .TRUE. s ao ativados em cada comando no <corpo> do construto. O <corpo> consiste em um ou mais dos seguintes: express oes e atribui c oes de elementos de matrizes, comandos ou construtos WHERE e outros comandos ou construtos FORALL. Usualmente, o sub-objeto (submatriz, por exemplo) no lado esquerdo de uma atribui c ao no <corpo> far a refer encia a cada < ndice> dos construtos nos quais ele est a imerso, como parte da identica c ao do sub-objeto. Nenhum dos comandos no <corpo> pode conter uma ramica c ao ou ser acess vel atrav es de algum comando de desvio de uxo, tal como o GO TO. Rotinas externas podem ser acessadas de dentro do <corpo> ou de dentro do cabe calho do construto (na m ascara, por exemplo). Todas as rotinas invocadas dentro desta estrutura devem ser puras (se c ao 8.2.16). O programa-exemplo 6.3 (programa tesforall) ilustra uma aplica c ao simples do construto FORALL, enquanto que o programa 6.4 (programa tesforall2) calcula a transposta de uma matriz. Pode-se notar aqui que o comando FORALL n ao acarreta em erro, uma vez que as atribui c oes s ao inicialmente armazenadas em espa co tempor ario e somente no nal s ao transferidas aos componentes da matriz A.
2O
que e denominado de a mbito (scope).
64
6.10. Comando e construto FORALL
Programa 6.3: Exemplo simples do construto FORALL.
program t e s f o r a l l i m p l i c i t none integer , dimension ( 3 0 ) : : a , b integer : : n ! f o r a l l ( n =1:30) a ( n)= n b ( n)= a(30 n+1) end f o r a l l print * , Vetor a : print * , a print * , print * , Vetor b : print * , b end program t e s f o r a l l
Programa 6.4: Calcula a transposta de uma matriz utilizando o comando FORALL.
program t e s f o r a l l 2 i m p l i c i t none integer , dimension ( 3 , 3 ) : : a integer : : i , j a= r e s h a p e ( s o u r c e= ( / ( i , i= 1 , 9 ) / ) , shape= ( / 3 , 3 / ) ) print * , Matriz A: print * , a ( 1 , : ) print * , a ( 2 , : ) print * , a ( 3 , : ) f o r a l l ( i= 1 : 3 , j= 1 : 3 ) a ( i , j )= a ( j , i ) print * , T ra nsposta de A: print * , a ( 1 , : ) print * , a ( 2 , : ) print * , a ( 3 , : ) end program t e s f o r a l l 2
Cap tulo 7
Rotinas Intr nsecas

Em uma linguagem de programa c ao destinada a aplica c oes cient cas h a uma exig encia obvia para que as fun c oes matem aticas mais requisitadas sejam oferecidas como parte da pr opria linguagem, ao inv es de terem de ser todas implementadas pelo programador. Al em disso, ao serem fornecidas como parte do compilador, espera-se que estas fun c oes tenham sido altamente otimizadas e testadas. A eci encia das rotinas intr nsecas quando estas manipulam matrizes em computadores vetoriais ou paralelos deve ser particularmente marcante, porque uma u nica chamada ` a rotina deve causar um n umero grande de opera c oes individuais sendo feitas simultaneamente, sendo o c odigo que as implementa otimizado para levar em conta todos os recursos de hardware dispon veis. No padr ao do Fortran 90/95 h a mais de cem rotinas intr nsecas ao todo. Elas se dividem em grupos distintos, os quais ser ao descritos em certo detalhe. Certos compiladores em particular poder ao oferecer ainda mais rotinas, al em das oferecidas pelo padr ao da linguagem; contudo, o pre co a pagar e a falta de portabilidade de programas que usam rotinas fora do grupo-padr ao. Al em disso, rotinas extras somente poder ao ser oferecidas ao usu ario atrav es de m odulos (cap tulo 8). Ao longo deste cap tulo, as rotinas intr nsecas ser ao naturalmente divididas em fun c oes e subrotinas. A distin c ao entre estas duas classes de rotinas ser a discutida com mais detalhes no cap tulo 8.
7.1
Categorias de rotinas intr nsecas
H a quatro categorias de rotinas intr nsecas: Rotinas elementais. S ao especicadas para argumentos escalares, mas podem tamb em ser aplicadas a matrizes conform aveis. No caso de uma fun c ao elemental, cada elemento da matriz resultante, caso exista, ser a obtido como se a fun c ao tivesse sido aplicada a cada elemento individual da matriz que foi usada como argumento desta fun c ao. No caso de uma subrotina elemental com um argumento matricial, cada argumento com intento IN ou INOUT deve ser uma matriz e cada elemento resultante ser a obtido como se a subrotina tivesse sido aplicada a cada elemento da matriz que e passada como argumento ` a subrotina. Fun c oes inquisidoras. Retornam propriedades dos seus argumentos principais que n ao dependem dos seus valores, somente do seu tipo e/ou esp ecie. Fun c oes transformacionais. S ao fun c oes que n ao s ao nem elementais nem inquisidoras. Elas usualmente t em argumentos matriciais e o resultado tamb em e uma matriz cujos elementos dependem dos elementos dos argumentos. Rotinas n ao-elementais. Rotinas que n ao se enquadram em nenhum dos tipos acima. As rotinas intr nsecas ser ao descritas posteriormente com base nesta categoriza c ao.
7.2
Declara c ao e atributo INTRINSIC
Um nome pode ser especicado como o nome de uma rotina intr nseca com a declara c ao INTRINSIC, o qual possui a forma geral: INTRINSIC <lista de nomes intr nsecos> 65
66
7.3. Fun c oes inquisidoras de qualquer tipo
onde <lista de nomes intr nsecos> e uma lista de nomes de rotinas intr nsecas. O uso desta declara c ao e recomendado quando se quer enfatizar ao compilador que certos nomes s ao destinados a rotinas intr nsecas. Isto pode ser u til quando o programador est a estendendo a deni c ao de uma rotina intr nseca, em um procedimento denominado sobrecarga de operador (operator overloading ), o qual faz uso de interfaces gen ericas (generic interfaces ). Para mais detalhes nestes recursos avan cados, ver Metcalf & Reid (1996) [4]. Alternativamente, uma ou mais fun c oes intr nsecas podem ser declaradas com o atributo INTRINSIC, no lugar da declara c ao. O atributo ou declara c ao INTRINSIC s ao excludentes em rela c ao ao atributo ou declara c ao EXTERNAL (se c ao 8.2.12).
7.3
Fun c oes inquisidoras de qualquer tipo
As seguintes s ao fun c oes inquisidoras, com argumentos que podem ser de qualquer tipo: ASSOCIATED(POINTER[,TARGET]). Quanto TARGET est a ausente, a fun c ao retorna o valor .TRUE. se o ponteiro (pointer) est a associado com um alvo (target) e retorna o valor .FALSE. em caso contr ario. O status de associa c ao de ponteiro de POINTER n ao deve ser indenido. Se TARGET estiver presente, este deve ter o mesmo tipo, esp ecie e posto de POINTER. O valor da fun c ao e .TRUE. se POINTER estiver associado a TARGET ou .FALSE. em caso contr ario. No caso de matrizes, .TRUE. e obtido somente se as formas s ao id enticas e elementos de matriz correspondentes, na ordem de elementos de matriz, est ao associadas umas com as outras. Se o comprimento do caractere ou tamanho da matriz s ao iguais a zero, .FALSO. e obtido. Um limite diferente, como no caso de ASSOCIATED(P,A) seguindo a atribui c ao de ponteiro P => A(:) quando LBOUND(A)= 0, e insuciente para causar um resultado .FALSE.. TARGET pode ser tamb em um ponteiro, em cujo caso seu alvo e comparado com o alvo de POINTER; o status de associa c ao de ponteiro de TARGET n ao deve ser indenido e se ou POINTER ou TARGET est ao dissociados, o resultado e .FALSE. PRESENT(A). Pode ser chamada em um sub-programa que possui um argumento mudo opcional A (ver se c ao 8.2.9) ou acesse este argumento mudo a partir de seu hospedeiro. A fun c ao retorna o valor .TRUE. se o argumento est a presente na chamada do sub-programa ou .FALSE. em caso contr ario. Se um argumento mudo opcional e usado como um argumento real na chamada de outra rotina, ele e considerado tamb em ausente pela rotina chamada. KIND(X). Tem o argumento X de qualquer tipo e esp ecie e o seu resultado tem o tipo inteiro padr ao e de valor igual ao valor do par ametro de esp ecie de X.
7.4
Fun c oes elementais num ericas
H a 17 fun c oes elementais destinadas ` a realiza c ao de opera c oes num ericas simples, muitas das quais realizam convers ao de tipo de vari aveis para alguns ou todos os argumentos.
7.4.1
Fun c oes elementais que podem converter
Se o especicador KIND estiver presente nas fun c oes elementais seguintes, este deve ser uma express ao inteira e fornecer um par ametro de esp ecie de tipo que seja suportado pelo processador. ABS(A). Retorna o valor absoluto de um argumento dos tipos inteiro, real ou complexo. O resultado e do tipo inteiro se A for inteiro e e real nos demais casos. O resultado e da mesma esp ecie que A. AIMAG(Z). Retorna a parte imagin aria do valor complexo Z. O tipo do resultado e real e a esp ecie e a mesma que Z. AINT(A[,KIND]). Trunca um valor real A em sentido ao zero para produzir um valor real cujos valores decimais s ao iguais a zero. Se o argumento KIND estiver presente, o resultado e da esp ecie dada por este; caso contr ario, retorna o resultado na esp ecie padr ao do tipo real. ANINT(A[,KIND]). Retorna um real cujo valor e o n umero completo (sem parte fracion aria) mais pr oximo de A. Se KIND estiver presente, o resultado e do tipo real da esp ecie denida; caso contr ario, o resultado ser a real da esp ecie padr ao.
Cap tulo 7. Rotinas Intr nsecas
67
CEILING(A). Retorna o menor inteiro maior ou igual ao seu argumento real. Se KIND estiver presente, o resultado ser a do tipo inteiro com a esp ecie denida pelo par ametro; caso contr ario, o resultado ser a inteiro da esp ecie padr ao. CMPLX(X[,Y][,KIND]). Converte X ou (X,Y) ao tipo complexo com a esp ecie denida pelo argumento KIND, caso presente, ou na esp ecie padr ao do tipo complexo em caso contr ario. Se Y for ausente, X pode ser dos tipos inteiro, real ou complexo. Se Y estiver presente, tanto X quanto Y devem ser dos tipos inteiro ou real. FLOOR(A[,KIND]). Retorna o maior inteiro menor ou igual a seu argumento real A. Se KIND estiver presente, o resultado e do tipo inteiro da esp ecie denida; caso contr ario, o resultado e inteiro da esp ecie padr ao. INT(A[,KIND]). Converte ao tipo inteiro da esp ecie padr ao ou dada pelo argumento KIND. O argumento A pode ser:
inteiro, em cujo caso INT(A)= A; real, em cujo caso o valor e truncado em sentido ao zero, ou complexo, em cujo caso somente a parte real e considerada e esta e truncada em sentido ao zero.
NINT(A[,KIND]). Retorna o valor inteiro mais pr oximo do real A. Se KIND estiver presente, o resultado e do tipo inteiro da esp ecie denida; caso contr ario, o resultado ser a inteiro da esp ecie padr ao. REAL(A[,KIND]). Converte ao tipo real da esp ecie dada pelo argumento KIND. O argumento A pode ser dos tipos inteiro, real ou complexo. Se A for complexo, a parte imagin aria e ignorada. Se o argumento KIND estiver ausente, o resultado ser a da esp ecie padr ao do tipo real se A for inteiro ou real e da mesma esp ecie de A se este for complexo.
7.4.2
Fun c oes elementais que n ao convertem
As seguintes s ao fun c oes elementais cujos resultados s ao do tipo e da esp ecie iguais aos do primeiro ou u nico argumento. Para aquelas que possuem mais de um argumento, todos devem ser do mesmo tipo e esp ecie. CONJG(Z). Retorna o conjugado do valor complexo Z. DIM(X,Y). Retorna MAX(X-Y,0) para argumentos que s ao ambos inteiros ou ambos reais. MAX(A1,A2[,A3,...]). Retorna o m aximo (maior valor) entre dois ou mais valores inteiros ou reais. MIN(A1,A2[,A3,...]). Retorna o m nimo (menor valor) entre dois ou mais valores inteiros ou reais. MOD(A,P). Retorna o restante de A m odulo P, ou seja, A-INT(A/P)*P. Se P=0, o resultado depende do processador. A e P devem ambos ser inteiros ou ambos reais. MODULO(A,P). Retorna A m odulo P quando A e P s ao ambos inteiros ou ambos reais; isto e, A-FLOOR(A/P)*P no caso real ou A-FLOOR(AP)*P no caso inteiro, onde representa divis ao matem atica ordin aria. Se P=0, o resultado depende do processador. SIGN(A,B). Retorna o valor absoluto de A vezes o sinal de B. A e B devem ser ambos inteiros ou ambos reais. Se B= 0 e e inteiro, seu sinal e assumido positivo. Se o processador n ao tem a capacidade de disting uir entre zeros reais positivos ou negativos ent ao, para B= 0.0 o sinal e assumido positivo.
7.5
Fun c oes elementais matem aticas
As seguintes s ao fun c oes elementais que calculam o conjunto imagem de fun c oes matem aticas elementares. O tipo e esp ecie do resultado s ao iguais aos do primeiro argumento, o qual, usualmente, eou nico. ACOS(X). Retorna a fun c ao arco cosseno (ou cos1 ) para valores reais do argumento X (|X| 1). O resultado e obtido em radianos no intervalo 0 ACOS(X) . ASIN(X). Retorna a fun c ao arco seno (ou sin1 ) para valores reais do argumento X (|X| 1). O resultado e obtido em radianos no intervalo /2 ASIN(X) /2.
68
7.6. Fun c oes elementais l ogicas e de caracteres
ATAN(X). Retorna a fun c ao arco tangente (ou tan1 ) para valores reais do argumento X ( < X < ). O resultado e obtido em radianos no intervalo /2 ATAN(X) /2. ATAN2(Y,X). Retorna a fun c ao arco tangente (ou tan1 ) para pares de argumentos reais, X e Y, ambos do mesmo tipo e esp ecie. O resultado e o valor principal do argumento do n umero complexo (X,Y), expresso em radianos no intervalo < ATAN2(Y, X) . Os valores de X e Y n ao devem ser simultaneamente nulos. COS(X). Retorna o valor da fun c ao cosseno para um argumento dos tipos real ou complexo. A unidade do argumento X e suposta ser radianos. COSH(X). Retorna o valor da fun c ao cosseno hiperb olico para um argumento X real. EXP(X). Retorna o valor da fun c ao exponencial para um argumento X real ou complexo. LOG(X). Retorna o valor da fun c ao logaritmo natural para um argumento X real ou complexo. No caso real, X deve ser positivo. No caso complexo, X n ao pode ser nulo e a parte imagin aria do resultado (Zi ) est a no intervalo < Zi . LOG10(X). Retorna o valor da fun c ao logaritmo de base 10 para um argumento X real e positivo. SIN(X). Retorna o valor da fun c ao seno para um argumento dos tipos real ou complexo. A unidade do argumento X e suposta ser radianos. SINH(X). Retorna o valor da fun c ao seno hiperb olico para um argumento X real. SQRT(X). Retorna o valor da fun c ao raiz quadrada para um argumento X real ou complexo. No caso real, X n ao pode ser negativo. No caso complexo, o resultado consiste na raiz principal, ou seja, a parte real do resultado e positiva ou nula. Quando a parte real do resultado for nula, a parte imagin aria e positiva ou nula. TAN(X). Retorna o valor da fun c ao tangente para um argumento X real. A unidade do argumento e suposta ser radianos. TANH(X). Retorna o valor da fun c ao tangente hiperb olica para um argumento X real.
7.6
7.6.1
Fun c oes elementais l ogicas e de caracteres

Convers oes caractere-inteiro
As seguintes s ao fun c oes elementais para converter um u nico caractere em um inteiro e vice-versa. ACHAR(I). O resultado e do tipo de caractere padr ao de comprimento um e retorna o caractere que est a na posi c ao especicada pelo valor inteiro I na tabela ASCII de caracteres (tabela 4.9). I deve estar no intervalo 0 I 127; caso contr ario, o resultado depende do processador. CHAR(I[,KIND]). O resultado e do tipo caractere de comprimento um. A esp ecie e dada pelo argumento opcional KIND, se presente ou, em caso contr ario, ser a a esp ecie padr ao. A fun c ao retorna o caractere na posi c ao I (tipo inteiro) da seq u encia de caracteres interna do processador associada com o par ametro de esp ecie relevante. I deve estar no intervalo 0 I n 1, onde n e o n umero de caracteres na seq u encia interna do processador. IACHAR(C). O resultado e do tipo inteiro padr ao e retorna a posi c ao do caractere C na tabela ASCII. Se C n ao est a na tabela, o resultado depende do processador. ICHAR(C). O resultado e do tipo inteiro padr ao e retorna a posi c ao do caractere C na seq u encia interna do processador associada com a esp ecie de C.
69
7.6.2
Fun c oes de compara c ao l exica
As seguintes fun c oes elementais aceitam strings de caracteres da esp ecie padr ao, realizam uma compara c ao l exica baseada na tabela ASCII e retornam um resultado l ogico da esp ecie padr ao. Se as strings tiverem comprimentos distintos, a mais curta e complementada com espa cos em branco. LGE(STRING_A,STRING_B). Retorna o valor .TRUE. se STRING_A segue STRING_B na seq u encia estabelecida pela tabela ASCII, ou a iguala. O resultado e .FALSE. em caso contr ario. LGT(STRING_A,STRING_B). Retorna o valor .TRUE. se STRING_A segue STRING_B na seq u encia estabelecida pela tabela ASCII. O resultado e .FALSE. em caso contr ario. LLE(STRING_A,STRING_B). Retorna o valor .TRUE. se STRING_A precede STRING_B na seq u encia estabelecida pela tabela ASCII, ou a iguala. O resultado e .FALSE. em caso contr ario. LLT(STRING_A,STRING_B). Retorna o valor .TRUE. se STRING_A precede STRING_B na seq u encia estabelecida pela tabela ASCII. O resultado e .FALSE. em caso contr ario.
7.6.3
Fun c oes elementais para manipula co es de strings
As seguintes s ao fun c oes elementais que manipulam strings. Os argumentos STRING, SUBSTRING e SET s ao sempre do tipo de caractere e, quando dois est ao presentes, ambos devem ser da mesma esp ecie. O resultado e da mesma esp ecie de STRING. ADJUSTL(STRING). Ajusta uma string ` a esquerda. Ou seja, remove os espa cos em branco no in cio da string e coloca o mesmo n umero de brancos no nal da string. ADJUSTR(STRING). Ajusta uma string ` a direita. Ou seja, remove os espa cos em branco no nal da string e coloca o mesmo n umero de brancos no in cio da string. INDEX(STRING,SUBSTRING[,BACK]). Retorna um valor do tipo inteiro padr ao, o qual consiste na posi c ao inicial de SUBSTRING como uma substring de STRING, ou zero se tal substring n ao existe. Se BACK (vari avel l ogica) est a ausente, ou se est a presente com o valor .FALSE., a posi c ao inicial da primeira das substrings e retornada; o valor 1 e retornado se SUBSTRING tem comprimento zero. Se BACK est a presente com valor .TRUE., a posi c ao inicial da u ltima das substrings e retornada; o valor LEN(STRING)+1 e retornado se SUBSTRING tem comprimento zero. LEN_TRIM(STRING). Retorna um valor inteiro padr ao correspondente ao comprimento de STRING, ignorando espa cos em branco no nal do argumento. SCAN(STRING,SET[,BACK]). Retorna um valor inteiro padr ao correspondente ` a posi c ao de um caractere de STRING que esteja em SET, ou zero se n ao houver tal caractere. Se a vari avel l ogica BACK est a ausente, ou presente com valor .FALSE., a posi c ao mais ` a esquerda deste caractere e retornada. Se BACK est a presente com valor .TRUE., a posi c ao mais ` a direita deste caractere e retornada. VERIFY(STRING,SET[,BACK]). Retorna o valor inteiro padr ao 0 se cada caractere em STRING aparece em SET, ou a posi c ao de um caractere de STRING que n ao esteja em SET. Se a vari avel l ogica BACK est a ausente, ou presente com valor .FALSE., a posi c ao mais ` a esquerda de tal caractere e retornada. Se BACK est a presente com valor .TRUE., a posi c ao mais ` a direita de tal caractere e retornada.
7.6.4
Convers ao l ogica
A fun c ao elemental a seguir converte de uma esp ecie do tipo l ogico em outra. LOGICAL(L[,KIND]). Retorna o valor l ogico id entico ao valor de L. A esp ecie do resultado e denida pelo argumento opcional KIND, caso esteja presente, ou e da esp ecie padr ao em caso contr ario.
7.7
7.7.1
Fun c oes n ao-elementais para manipula c ao de strings

Fun c ao inquisidora para manipula c ao de strings
LEN(STRING). Trata-se de uma fun c ao inquisidora que retorna um valor inteiro padr ao escalar que corresponde ao n umero de caracteres em STRING se esta e escalar ou de um elemento de STRING se a mesma e uma matriz. O valor de STRING n ao precisa estar denido.
70
7.8. Fun c oes inquisidoras e de manipula c oes num ericas
7.7.2
Fun c oes transformacionais para manipula c ao de strings
Existem duas fun c oes que n ao s ao elementais porque o comprimento do resultado depende do valor de um argumento. REPEAT(STRING,NCOPIES). Forma a string que consiste na concatena c ao de NCOPIES c opias de STRING, onde NCOPIES e do tipo inteiro e seu valor n ao deve ser negativo. Ambos argumentos devem ser escalares. TRIM(STRING). Retorna STRING com todos os espa cos em branco no nal da vari avel removidos. STRING deve ser escalar.
7.8
7.8.1
Fun c oes inquisidoras e de manipula c oes num ericas

Modelos para dados inteiros e reais
As fun c oes inquisidoras e de manipula c oes num ericas s ao denidas em termos de modelos de representa c ao de n umeros inteiro e reais para cada esp ecie suportada pelo processador. Para cada esp ecie do tipo inteiro, o modelo e:
q
i=s
k=1
wk rk1 ,
(7.1)
onde s = 1, q e um inteiro positivo, r e um inteiro maior que um (usualmente 2) e cada valor de wk e um inteiro no intervalo 0 wk < r. Para cada esp ecie do tipo real, o modelo e: x=0 e x=sb
k=1 e p
fk bk ,
(7.2)
onde s = 1, p e b s ao inteiros maiores que um, e e um inteiro no intervalo emin e emax e cada fk e um inteiro no intervalo 0 fk < b, exceto f1 , que e n ao nulo. Os valores de todos os par ametros nestes modelos s ao escolhidos para o processador de tal forma que o modelo melhor se ajuste ao hardware, desde que todos os n umeros sejam represent aveis.
7.8.2
Fun c oes num ericas inquisidoras
H a nove fun c oes inquisidoras que retornam valores para os modelos de dados associados com seus argumentos. Cada fun c ao tem um u nico argumento que pode ser escalar ou matricial e todas retornam um valor escalar. O valor per se do argumento n ao precisa ser denido, somente o seu tipo e esp ecie. DIGITS(X). Para X real ou inteiro, retorna o inteiro padr ao cujo valor e o n umero de d gitos signicantes no modelo que inclui X; isto e, retorna p para X real ou q para X inteiro. EPSILON(X). Para X real, retorna um resultado real com o mesmo tipo de X e que e quase indisting u vel do valor 1.0 no modelo que inclui X. Ou seja, a fun c ao calcula b1p . HUGE(X). Para X real ou inteiro, retorna o maior valor represent avel no modelo que inclui X. O resultado possui o mesmo tipo e esp ecie de X. O valor e 1 bp bemax para X real ou rq 1 para X inteiro. MAXEXPONENT(X). Para X real, retorna o inteiro padr ao emax , ou seja, o expoente m aximo no modelo que inclui X.
71
MINEXPONENT(X). Para X real, retorna o inteiro padr ao emin , ou seja, o expoente m nimo no modelo que inclui X. PRECISION(X). Para X real ou complexo, retorna um inteiro padr ao que cont em a precis ao decimal equivalente no modelo que representa n umeros reais da mesma esp ecie de X. O valor da fun c ao e INT((p 1)) LOG10(b))+k, onde k e 1 se b e uma pot encia inteira de 10 ou 0 em outro caso. RADIX(X). Para X real ou inteiro, retorna o inteiro padr ao que e a base no modelo que inclui X. Isto e, retorna b para X real ou r para X inteiro. RANGE(X). Para X inteiro, real ou complexo, retorna o inteiro padr ao que cont em o intervalo de expoentes decimais nos modelos representando n umeros reais ou inteiro da mesma esp ecie de X. O valor da fun c ao e INT(LOG10(huge)) para X inteiro e INT(MIN(LOG10(huge), LOG10(tiny ))) para X real, onde huge e tiny s ao, respectivamente, o maior e o menor n umeros positivos nos modelos. TINY(X). Para X real, retorna o menor n umero positivo, bemin 1 no modelo que inclui X. O resultado e do mesmo tipo e esp ecie de X.
7.8.3
Fun c oes elementais que manipulam quantidades reais
H a sete fun c oes elementais cujo primeiro ou u nico argumento e do tipo real e que retorna valores relacionados aos componentes dos modelos de valores associados ao valor do argumento. EXPONENT(X). Retorna o inteiro padr ao cujo valor e a parte de expoente e de X quando representado como um n umero de modelo. Se X=0, o resultado tamb em e nulo. FRACTION(X). Retorna uma quantidade real da mesma esp ecie que X e cujo valor e a parte fracion aria de X quando representado como um n umero de modelo; isto e, a fun c ao retorna Xbe . NEAREST(X,S). Retorna uma quantidade real da mesma esp ecie que X e cujo valor e o n umero distinto mais pr oximo de X no sentido dado pelo sinal da quantidade real S. O valor de S n ao pode ser nulo. RRSPACING(X). Retorna uma quantidade real da mesma esp ecie que X cujo valor e a rec proca do espa camento relativo dos n umeros de modelo pr oximos a X; isto e, a fun c ao retorna |Xbe | bp . SCALE(X,I). Retorna uma quantidade real da mesma esp ecie que X cujo valor e XbI , onde b e a base do modelo para X e I e do tipo inteiro. SET_EXPONENT(X,I). Retorna uma quantidade real da mesma esp ecie que X cuja parte fracion aria e a parte fracion aria da representa c ao de X e cuja parte exponencial e I; isto e, a fun c ao retorna Xb1e . SPACING(X). Retorna uma quantidade real da mesma esp ecie que X cujo valor e o espa camento absoluto do modelo de n umeros pr oximos a X. O resultado e bep se X e n ao nulo e este resultado est a dentro do intervalo de n umeros represent aveis. Caso contr ario, a fun c ao retorna TINY(X).
7.8.4
Fun c oes transformacionais para valores de esp ecie (kind)
H a duas fun c oes que retornam o menor valor do par ametro de esp ecie que ir a satisfazer um dado requerimento num erico. As fun c oes t em argumentos e resultados escalares; por em s ao classicadas como transformacionais. Estas fun c oes j a foram discutidas na se c ao 3.7.3. SELECTED_INT_KIND(R). Retorna o inteiro escalar padr ao que e o valor do par ametro da esp ecie para um dado do tipo inteiro capaz de representar todos os valor inteiros n no intervalo 10R < n < 10R , onde R e um inteiro escalar. Se mais de uma esp ecie for dispon vel, a esp ecie com menor intervalo exponencial e escolhida. Se nenhuma esp ecie e dispon vel, o resultado e -1.
72
7.9. Rotinas de manipula c ao de bits
SELECTED_REAL_KIND([P][,R]). Retorna o inteiro escalar padr ao que e o valor do par ametro da esp ecie para um dado do tipo real com precis ao decimal (conforme retornada pela fun c ao PRECISION) no m nimo igual a P e intervalo de expoente decimal (conforme retornado pela fun c ao RANGE) no m nimo igual a R. Se mais de uma esp ecie for dispon vel, a esp ecie com a menor precis ao decimal e escolhida. Tanto P quanto R s ao inteiros escalares; pelo menos um destes deve estar presente. Se n ao houver esp ecie dispon vel, o resultado e: -1: se a precis ao requerida n ao for dispon vel; -2: se um intervalo de expoente grande o suciente n ao for dispon vel; -3: se ambos n ao forem dispon veis.
7.9
Rotinas de manipula c ao de bits
H a onze rotinas para manipular bits contidos em quantidades inteiras. Estas rotinas s ao elementais, quando apropriado. As rotinas s ao baseadas em um modelo no qual um valor inteiro e representado por s bits wk , com k = 0, 1, . . . , s 1, em uma seq u encia da direita para a esquerda, baseada no valor n ao-negativo
s1
wk 2k .
k=0
Este modelo e v alido somente no contexto destas rotinas intr nsecas e e id entico ao modelo de n umeros inteiros (7.1) quando r e uma pot encia inteira de 2 e ws1 = 0; mas quando ws1 = 1 os modelos diferem.
7.9.1
Fun c ao inquisidora
BIT_SIZE(I). Retorna o n umero de bits no modelo para bits dentro de um inteiro da mesma esp ecie que I. O resultado e um inteiro escalar da mesma esp ecie que I.
7.9.2
Fun c oes elementais
BTEST(I,POS). Retorna o valor l ogico da esp ecie padr ao .TRUE. se o bit POS do inteiro I tem valor 1 e retorna .FALSE. em outra situa c ao. POS deve ser um inteiro com valor no intervalo 0 POS < BIT SIZE(I). IAND(I,J). Retorna o l ogico AND de todos os bits em I e bits correspondentes em J, de acordo com a tabela-verdade I 1100 J 1010 I AND(I, J) 1 0 0 0 I e J devem ser do mesmo tipo; o resultado tamb em ser a do mesmo tipo. IBCLR(I,POS). Retorna um inteiro do mesmo tipo que I e valor igual ao de I exceto que o bit POS e levado a 0. POS deve ser um inteiro com valor no intervalo 0 POS < BIT SIZE(I). IBITS(I,POS,LEN). Retorna um inteiro do mesmo tipo que I e valor igual aos LEN bits de I iniciando no bit POS ajustado ` a direita e com todos os outros bits iguais a 0. POS e LEN devem ser inteiros positivos tais que POS + LEN BIT SIZE(I). IBSET(I,POS). Retorna um inteiro do mesmo tipo que I e valor igual ao de I exceto que o bit POS e levado a 1. POS deve ser um inteiro com valor no intervalo 0 POS < BIT SIZE(I). IEOR(I,J). Retorna o OU l ogico exclusivo de todos os bits de I e correspondentes bits em J, de acordo com a tabela-verdade I 1100 J 1010 I EOR(I, J) 0 1 1 0 I e J devem ser do mesmo tipo; o resultado tamb em ser a do mesmo tipo.
73
IOR(I,J). Retorna o OU l ogico inclusivo de todos os bits de I e correspondentes bits em J, de acordo com a tabela-verdade I 1100 J 1010 I IOR(I, J) 1 1 1 0 I e J devem ser do mesmo tipo; o resultado tamb em ser a do mesmo tipo. ISHFT(I,SHIFT). Retorna um inteiro do mesmo tipo que I e valor igual ao de I exceto que os bits s ao deslocados SHIFT posi c oes para a esquerda (-ISHIFT desloca para a direita se SHIFT for positivo). Zeros s ao inseridos a partir da extremidade oposta. SHIFT deve ser um inteiro com valor que satisfaz a inegualdade |SHIFT| BIT SIZE(I). ISHFTC(I,SHIFT[,SIZE]). Retorna um inteiro do mesmo tipo que I e valor igual ao de I exceto que os SIZE bits mais ` a direita (ou todos os bits se SIZE for ausente) s ao deslocados de forma circular SHIFT posi c oes para a esquerda (-ISHIFT desloca para a direita se SHIFT for positivo). Zeros s ao inseridos a partir da extremidade oposta. SHIFT deve ser um inteiro com valor que n ao excede o valor de SIZE ou BIT_SIZE(I), se SIZE estiver ausente. NOT(I). Retorna o complemento l ogico de todos os bits em I, de acordo com a tabela-verdade I 01 NOT(I) 1 0
7.9.3
Subrotina elemental
MVBITS(FROM,FROMPOS,LEN,TO,TOPOS). Copia a seq u encia de bits em FROM que inicia na posi c ao FROMPOS e tem comprimento LEN para TO, iniciando na posi c ao TOPOS. Os outros bits de TO permanecem inalterados. FROM, FROMPOS, LEN e TOPOS s ao todos inteiros com intent IN e devem ter valores que satisfazem as inegualdades: LEN 0, FROMPOS+LEN BIT_SIZE(FROM), FROMPOS 0, TOPOS 0 e TOPOS+LEN BIT_SIZE(TO). TO e um inteiro com intent INOUT; ele deve ser da mesma esp ecie que FROM. A mesma vari avel pode ser especicada para FROM e TO.
7.10
Fun c ao de transfer encia
A fun c ao de transfer encia permite que dados de um tipo sejam transferidos a outro tipo sem que a representa c ao f sica dos mesmos seja alterada. Esta fun c ao pode ser u til, por exemplo, ao se escrever um sistema de armazenamento e recupera c ao de dados; o sistema pode ser escrito para uma dado tipo, por exemplo, inteiro, e os outros tipos s ao obtidos atrav es de transfer encias de e para este tipo. TRANSFER(SOURCE,MOLD[,SIZE]). Retorna um valor do tipo e esp ecie de MOLD. Quando SIZE estiver ausente, o resultado e escalar se MOLD for escalar e e de posto 1 e tamanho suciente para armazenar toda a SOURCE se MOLD for uma matriz. Quando SIZE estiver presente, o resultado e de posto 1 e tamanho SIZE. Se a representa c ao f sica do resultado e t ao ou mais longa que o tamanho de SOURCE, o resultado cont em SOURCE como sua parte inicial e o resto e indenido; em outros casos, o resultado e a parte inicial de SOURCE. Como o posto do resultado depende se SIZE e ou n ao especicado, o argumento em si n ao pode ser um argumento opcional.
7.11
Fun co es de multiplica c ao vetorial ou matricial
H a duas fun c oes transformacionais que realizam multiplica c oes vetorial ou matricial. Elas possuem dois argumentos que s ao ambos de um tipo num erico (inteiro, real ou complexo) ou ambas do tipo l ogico. O resultado e do mesmo tipo e esp ecie como seria resultante das opera c oes de multiplica c ao ou .AND. entre dois escalares. As fun c oes SUM e ANY, usadas nas deni c oes abaixo, s ao denidas na se c ao 7.12.1 abaixo. DOT_PRODUCT(VETOR_A,VETOR_B). Requer dois argumentos, ambos de posto 1 e do mesmo tamanho. Se VETOR_A e dos tipos inteiro ou real, a fun c ao retorna SUM(VETOR_A*VETOR_B); se VETOR_A e do tipo complexo, a fun c ao retorna SUM(CONJG(VETOR_A)*VETOR_B); e se VETOR_A e do tipo l ogico, a fun c ao retorna ANY(VETOR_A .AND. VETOR_B). MATMUL(MATRIZ_A,MATRIZ_B). Realiza a multiplica c ao escalar. Para argumentos num ericos, tr es casos s ao poss veis:
74
7.12. Fun c oes transformacionais que reduzem matrizes 1. MATRIZ_A tem forma (/n,m/) e MATRIZ_B tem forma (/m,k/). O resultado tem forma (/n,k/) e o elemento (i, j ) tem o valor dado por SUM(MATRIZ_A(I,:)*MATRIZ_B(:,J)). 2. MATRIZ_A tem forma (/m/) e MATRIZ_B tem forma (/m,k/). O resultado tem forma (/k/) e o elemento j tem o valor dado por SUM(MATRI_A*MATRIZ_B(:,J)). 3. MATRIZ_A tem forma (/n,m/) e MATRIZ_B tem forma (/m/). O resultado tem forma (/n/) e o elemento i tem o valor dado por SUM(MATRIZ_A(I,:)*MATRIZ_B). Para argumentos l ogicos, as formas s ao as mesmas que para argumentos num ericos e os valores s ao determinados pela substitui c ao da fun c ao SUM e do operador * pela fun c ao ANY e pelo operador .AND..
7.12
Fun co es transformacionais que reduzem matrizes
H a sete fun c oes transformacionais que executam opera c oes em matrizes, tais como somar seus elementos.
7.12.1
Caso de argumento u nico
Nas suas formas mais simples, estas fun c oes t em um u nico argumento matricial e o resultado e um valor escalar. Todas, exceto COUNT tem o resultado do mesmo tipo e esp ecie que o argumento. ALL(MASK). Retorna o valor .TRUE. se todos os elementos da matriz l ogica MASK forem verdadeiros ou se MASK for nula; caso contr ario, retorna o valor .FALSE. ANY(MASK). Retorna o valor .TRUE. se algum dos elementos da matriz l ogica MASK for verdadeiro e o valor .FALSE. se todos os elementos forem falsos ou se a matriz for nula. COUNT(MASK). Retorna o valor inteiro padr ao igual ao n umero de elementos da matriz MASK que t em o valor .TRUE. MAXVAL(ARRAY). Retorna o valor m aximo dentre os elementos da matriz ARRAY, a qual pode ser inteira ou real. Se ARRAY for nula, a fun c ao retorna o valor negativo de maior magnitude suportado pelo processador. MINVAL(ARRAY). Retorna o valor m nimo dentre os elementos da matriz ARRAY, a qual pode ser inteira ou real. Se ARRAY for nula, a fun c ao retorna o valor positivo de maior magnitude suportado pelo processador. PRODUCT(ARRAY). Retorna o produto de todos os elementos de uma matriz inteira, real ou complexa. A fun c ao retorna o valor 1 se ARRAY for nula. SUM(ARRAY). Retorna a soma de todos os elementos de uma matriz inteira, real ou complexa. A fun c ao retorna o valor 0 se ARRAY for nula.
7.12.2
Argumento opcional DIM
Todas as fun c oes acima t em um segundo argumento opcional DIM, o qual e um inteiro escalar. Se este argumento est a presente, a opera c ao e aplicada a todas as se c oes de posto 1 que varrem atrav es da dimens ao DIM para produzir uma matriz de posto reduzido por um e extens oes iguais ` as extens oes nas outras dimens oes. Por exemplo, se A e uma matriz real de forma (/4,5,6/), SUM(A,DIM=2) e uma matriz real de forma (/4,6/) e o seu elemento (i, j ) tem o valor dado por SUM(A(I,:,J)).
7.12.3
Argumento opcional MASK
As fun c oes MAXVAL, MINVAL, PRODUCT e SUM t em um terceiro argumento opcional; uma matriz l ogica MASK. Se esta matriz estiver presente, ela deve ter a mesma forma que o primeiro argumento e a opera c ao e aplicada aos elementos do primeiro argumento correspondentes aos elementos verdadeiros de MASK. Por exemplo, SUM(A, MASK= A>0) soma todos os elementos positivos da matriz A. O argumento MASK afeta somente o valor da fun c ao e n ao afeta o desenvolvimento de argumentos que s ao express oes matriciais.
75
7.13
Fun co es inquisidoras de matrizes
H a cinco fun c oes que inquirem sobre os limites, forma, tamanho e status de aloca c ao de uma matriz de qualquer tipo. Uma vez que o resultado depende somente nas propriedades da matriz, o valor desta n ao necessita ser denido.
7.13.1
Status de aloca c ao
ALLOCATED(ARRAY). Retorna, quando a matriz aloc avel ARRAY est a correntemente alocada, o valor .TRUE.; na outra situa c ao, o valor .FALSE. e retornado. Se os status da aloca c ao e indenido, o resultado tamb em e indenido.
7.13.2
Limites, forma e tamanho
As fun c oes a seguir inquirem sobre as propriedades de uma matriz. No caso de uma matriz aloc avel, esta deve estar alocada. No caso de um ponteiro (pointer) , ele deve estar associado a um alvo (target) . Uma se c ao de matriz ou uma express ao matricial e assumida ter limite inferior 1 e limite superior igual ` as extens oes. LBOUND(ARRAY[,DIM]). Quando DIM e ausente, retorna uma matriz inteira padr ao de posto um, a qual cont em os limites inferiores. Quando DIM e presente, este deve ser um inteiro escalar e o resultado e um escalar inteiro padr ao com o valor do limite inferior na dimens ao DIM. Como o posto do resultado depende da presen ca de DIM, o argumento da fun c ao n ao pode ser, por sua vez, um argumento mudo opcional. SHAPE(SOURCE). Retorna um vetor inteiro padr ao contendo a forma da matriz ou escalar SOURCE. No caso de um escalar, o resultado tem tamanho zero. SIZE(ARRAY[,DIM]). Retorna um escalar inteiro padr ao igual ao tamanho da matriz ARRAY ou a extens ao ao longo da dimens ao DIM, caso este argumento esteja presente. UBOUND(ARRAY[,DIM]). Similar a LBOUND exceto que retorna limites superiores.
7.14
Fun co es de constru c ao e manipula c ao de matrizes
H a oito fun c oes que constroem ou manipulam matrizes de qualquer tipo.
7.14.1
Fun c ao elemental MERGE
MERGE(TSOURCE,FSOURCE,MASK). Trata-se de uma fun c ao elemental. TSOURCE pode ter qualquer tipo e FSOURCE deve ser do mesmo tipo e esp ecie. MASK deve ser do tipo l ogico. O resultado e TSOURCE se MASK e verdadeiro ou FSOURCE no contr ario.
7.14.2
Agrupando e desagrupando matrizes
A fun c ao transformacional PACK agrupa dentro de um vetor aqueles elemento de uma matriz que s ao selecionados por uma matriz l ogica conforme e a fun c ao transformacional UNPACK executa a opera c ao reversa. Os elementos s ao tomados na ordem dos elementos das matrizes. PACK(ARRAY,MASK[,VECTOR]). Quando VECTOR e ausente, retorna um vetor contendo os elementos de ARRAY correspondentes aos valores verdadeiros de MASK na ordem dos elementos das matrizes. MASK pode ser um escalar de valor .TRUE.; em cujo caso, todos os elementos s ao selecionados. Se VECTOR e presente, este deve ser um vetor do mesmo tipo e esp ecie de ARRAY e tamanho no m nimo igual ao n umero t de elementos selecionados. O resultado, neste caso, tem tamanho igual ao tamanho n do VECTOR; se t < n, elementos i do resultado para i > t s ao os elementos correspondentes de VECTOR. UNPACK(VECTOR,MASK,FIELD). Retorna uma matriz do tipo e esp ecie de VECTOR e da forma de MASK. MASK deve ser uma matriz l ogica e VECTOR deve ser um vetor de tamanho no m nimo igual ao n umero de elementos verdadeiros de MASK. FIELD deve ser do mesmo tipo e esp ecie de VECTOR e deve ou ser escalar ou ter a mesma forma que MASK. O elemento do resultado correspondendo ao i - esimo elemento verdadeiro de MASK, na ordem dos elementos da matriz, e o i - esimo elemento de VECTOR; todos os outros s ao iguais aos correspondentes elementos de FIELD se este for uma matriz ou igual a FIELD se este for um escalar.
76
7.15. Fun c oes transformacionais para localiza c ao geom etrica
7.14.3
Alterando a forma de uma matriz
A fun c ao transformacional RESHAPE permite que a forma de uma matriz seja alterada, com a poss vel permuta c ao dos ndices. RESHAPE(SOURCE,SHAPE[,PAD][,ORDER]). Retorna uma matriz com forma dada pelo vetor inteiro SHAPE e tipo e esp ecie iguais aos da matriz SOURCE. O tamanho de SHAPE deve ser constante e seus elementos n ao podem ser negativos. Se PAD est a presente, esta deve ser uma matriz do mesmo tipo e esp ecie de SOURCE. Se PAD estiver ausente ou for uma matriz de tamanho zero, o tamanho do resultado n ao deve exceder o tamanho de SOURCE. Se ORDER estiver ausente, os elementos da matriz resultante, arranjados na ordem de elementos de matrizes (se c ao 6.6.2), s ao os elementos de SOURCE, seguidos por c opias de PAD, tamb em na ordem de elementos de matrizes. Se ORDER estiver presente, este deve ser um vetor inteiro com um valor que e uma permuta c ao de (1, 2, ..., n ); os elementos R(s1 , . . . , sn ) do resultado, tomados na ordem dos ndices para a matriz tendo elementos R(sordem(1) , . . . , sordem(n) ), s ao aqueles de SOURCE na ordem de elementos de matriz seguidos por c opias de PAD, tamb em na ordem de elementos de matriz. Por exemplo, se ORDER tem o valor (/3,1,2/), os elementos R(1,1,1), R(1,1,2), ..., R(1,1,k ), R(2,1,1), R(2,1,2), ... correspondem aos elementos de SOURCE e PAD na ordem de elementos de matriz.
7.14.4
Fun c ao transformacional para duplica c ao
SPREAD(SOURCE,DIM,NCOPIES). Retorna uma matriz do tipo e esp ecie de SOURCE e de posto acrescido por um. SOURCE pode ser escalar ou matriz. DIM e NCOPIES s ao inteiros escalares. O resultado cont em MAX(NCOPIES,0) c opias de SOURCE e o elemento (r1 , . . . , rn+1 ) do resultado e SOURCE(s1 , . . . , sn ), onde (s1 , . . . , sn ) e (r1 , . . . , rn+1 ) com subscrito DIM omitido (ou a pr opria SOURCE se esta for um escalar).
7.14.5
Fun co es de deslocamento matricial
CSHIFT(ARRAY,SHIFT[,DIM]). Retorna uma matriz do mesmo tipo, esp ecie e forma de ARRAY. DIM e um escalar inteiro. Se DIM for omitido, o seu valor ser a assumido igual a 1. SHIFT e do tipo inteiro e deve ser um escalar se ARRAY tiver posto um. Se SHIFT e escalar, o resultado e obtido deslocando-se toda se c ao vetorial que se estende ao longo da dimens ao DIM de forma circular SHIFT vezes. O sentido do deslocamento depende do sinal de SHIFT e pode ser determinado a partir do caso com SHIFT= 1 e ARRAY de posto um e tamanho m, quando o elemento i do resultado e ARRAY(i + 1), i= 1, 2, ..., m -1 e o elemento m e ARRAY(1). Se SHIFT for uma matriz, esta deve ter a forma de ARRAY com a dimens ao DIM omitida; desta forma, SHIFT oferece um valor distinto para cada deslocamento. id EOSHIFT(ARRAY,SHIFT[,BOUNDARY][,DIM]). E entica a CSHIFT, exceto que um deslocamento nal e executado e valores de borda s ao inseridos nas lacunas assim criadas. BOUNDARY pode ser omitida quando ARRAY tiver tipo intr nsecos, em cujo caso o valor zero e inserido para os casos inteiro, real e complexo; .FALSE. no caso l ogico e brancos no caso de caracteres. Se BOUNDARY estiver presente, deve ser do mesmo tipo e esp ecie de ARRAY; ele pode ser um escalar e prover todos os valores necess arios ou pode ser uma matriz cuja forma e a de ARRAY com dimens ao DIM omitida e prover um valor separado para cada deslocamento.
7.14.6
Transposta de uma matriz
A fun c ao TRANSPOSE executa a transposi ca o matricial para qualquer matriz de posto dois. TRANSPOSE(MATRIX). Retorna uma matriz do mesmo tipo e esp ecie da matriz de posto dois MATRIX. Elemento (i,j ) do resultado e igual a MATRIX(i,j ).
7.15
Fun co es transformacionais para localiza c ao geom etrica
H a duas fun c oes transformacionais que localizam as posi c oes dos valores m aximos e m nimos de uma matriz inteira ou real. MAXLOC(ARRAY,DIM[,MASK]) ou MAXLOC(ARRAY[,MASK]). Retorna um vetor inteiro padr ao de tamanho igual ao posto de ARRAY. Seu valor e a seq u encia de subscritos de um elemento de valor m aximo (dentre aqueles correspondentes aos elementos de valor .TRUE. da matriz l ogica MASK, caso esta exista), como se todos os limites inferiores de ARRAY fossem iguais a 1. Se houver mais de um elemento com o mesmo
77
valor m aximo, o primeiro na ordem de elementos de matriz e assumido. Caso o argumento DIM esteja presente, este e um escalar inteiro padr ao que indica a dimens ao ao longo da qual o valor m aximo deve ser procurado. O compilador pode disting uir sem aux lio caso o segundo argumento seja DIM ou MASK pelo fato de que o tipo de vari avel e distinto. MINLOC(ARRAY,DIM[,MASK]) ou MAXLOC(ARRAY[,MASK]). Retorna um vetor inteiro padr ao de tamanho igual ao posto de ARRAY. Seu valor e a seq u encia de subscritos de um elemento de valor m nimo (dentre aqueles correspondentes aos elementos de valor .TRUE. da matriz l ogica MASK, caso esta exista), como se todos os limites inferiores de ARRAY fossem iguais a 1. Se houver mais de um elemento com o mesmo valor m nimo, o primeiro na ordem de elementos de matriz e assumido.
7.16
Fun c ao transformacional para dissocia c ao de ponteiro
Em Fortran 95, a fun c ao NULL est a dispon vel para fornecer status de dissociado a ponteiros. NULL([MOLDE]). Retorna um pointer dissociado. O argumento MOLDE e um ponteiro de qualquer tipo e que pode ter qualquer status, inclusive de indenido. O tipo, esp ecie e posto do resultado s ao aqueles de MOLDE se ele est a presente; em caso contr ario, s ao aqueles do objeto com o qual o ponteiro est a associado.
7.17
Subrotinas intr nsecas n ao-elementais
H a cinco subrotinas intr nsecas n ao elementais, as quais foram escolhidas ser subrotinas no lugar de fun c oes devido ` a necessidade destas retornarem diversas informa c oes atrav es de seus argumentos.
7.17.1
Rel ogio de tempo real
H a duas subrotinas que retornam informa c ao acerca do rel ogio de tempo real; a primeiro e baseada no padr ao ISO 8601 (Representa c ao de datas e tempos). Assume-se que exista um rel ogio b asico no sistema que e incrementado por um para cada contagem de tempo at e que um valor m aximo COUNT_MAX e alcan cado e da , na pr oxima contagem de tempo, este e zerado. Valores padronizados s ao retornados em sistemas sem rel ogio. Todos os argumentos t em inten c ao OUT (se c ao 8.2.5). Adicionalmente, h a uma subrotina que acessa o rel ogio interno do processador. Acesso a qualquer argumento opcional pode ser realizado atrav es do uso das palavras-chave (se c oes 8.2.8 e 8.2.9). CALL DATE_AND_TIME([DATE][,TIME][,ZONE][,VALUES]). Retorna os seguintes valores (com valores-padr ao nulos ou -HUGE(0), conforme apropriado, caso n ao haja rel ogio): DATE e uma vari avel escalar de caractere da esp ecie padr ao que cont em a data na forma ccyymmdd, correspondendo ao s eculo, ano, m es e dia, respectivamente. TIME e uma vari avel escalar de caractere padr ao que cont em o tempo na forma hhmmss.sss, correspondendo a horas, minutos, segundos e milisegundos, respectivamente. ZONE e uma vari avel escalar de caractere padr ao que e xada como a diferen ca entre o tempo local e o Tempo Coordenado Universal (UTC, de Coordinated Universal Time, tamb em conhecido como Tempo M edio de Greenwich, ou Greenwich Mean Time ) na forma Shhmm, correspondendo ao sinal, horas e minutos, respectivamente. Por exemplo, a hora local de Bras lia corresponde a UTC= -0300. VALUES e um vetor inteiro padr ao que cont em a seguinte seq u encia de valores: o ano, o m es do ano, o dia do m es, a diferen ca temporal em minutos com rela c ao ao UTC, a hora do dia, os minutos da hora, os segundos do minuto e os milisegundos do segundo. CALL SYSTEM_CLOCK([COUNT][,COUNT_RATE][,COUNT_MAX]). Retorna o seguinte: COUNT e uma vari avel escalar inteira padr ao que cont em o valor, dependente do processador, que correspondem ao valor corrente do rel ogio do processador, ou -HUGE(0) caso n ao haja rel ogio. Na primeira chamada da subrotina, o processador pode xar um valor inicial igual a zero. COUNT_RATE e uma vari avel escalar inteira padr ao que cont em o n umero de contagens por segundo do rel ogio, ou zero caso n ao haja rel ogio. COUNT_MAX e uma vari avel escalar inteira padr ao que cont em o valor m aximo que COUNT pode assumir, ou zero caso n ao haja rel ogio.
78
7.17. Subrotinas intr nsecas n ao-elementais
7.17.2
Tempo da CPU
Em Fortran 95, h a uma subrotina intr nseca n ao-elemental que retorna o tempo do processador. CALL CPU_TIME(TIME). Retorna o seguinte: TIME e uma vari avel real escalar padr ao ` a qual e atribu da uma aproxima c ao (dependente de processador) do tempo do processador em segundos, ou um valor negativo (dependente de processador) caso n ao haja rel ogio.
7.17.3
N umeros aleat orios
Uma seq u encia de n umeros pseudo-aleat orios e gerada a partir de uma semente que e fornecida como um vetor de n umeros inteiros. A subrotina RANDOM_NUMBER retorna os n umeros pseudo-aleat orios e a subrotina RANDOM_SEED permite que uma inquiri c ao seja feita a respeito do tamanho ou valor do vetor-semente e, ent ao, redenir o mesmo. As subrotinas fornecem uma interface a uma seq u encia que depende do processador. CALL RANDOM_NUMBER(COLHE) Retorna um n umero pseudo-aleat orio a partir da distribui c ao uniforme de n umeros no intervalo 0 x < 1 ou um vetor destes n umeros. COLHE tem inten c ao OUT, pode ser um escalar ou vetor e deve ser do tipo real. CALL RANDOM_SEED([SIZE][,PUT][,GET]). Tem os argumentos abaixo. N ao mais de um argumento pode ser especicado; caso nenhum argumento seja fornecido, a semente e xada a um valor dependente do processador. SIZE tem inten c ao OUT e e um inteiro escalar padr ao que o processador xa com o tamanho n do vetor-semente. PUT tem inten c ao IN e e um vetor inteiro padr ao de tamanho n que e usado pelo processador para xar uma nova semente. Um processador pode xar o mesmo valor de semente para mais de um valor de PUT. GET tem inten c ao OUT e e um vetor inteiro padr ao de tamanho n que o processador xa como o valor atual da semente.
Cap tulo 8
Sub-Programas e M odulos
Como foi visto nos cap tulos anteriores, e poss vel escrever um programa completo em Fortran em um u nico arquivo, ou como uma unidade simples. Contudo, se o c odigo e sucientemente complexo, pode ser necess ario que um determinado conjunto de instru c oes seja realizado repetidas vezes, em pontos distintos do programa. Um exemplo desta situa c ao seria a deni c ao de uma fun c ao extr nseca, ou seja, n ao contida no conjunto de fun c oes intr nsecas discutidas no cap tulo 7. Neste caso, e melhor quebrar o programa em unidades distintas. Cada uma das unidades de programa corresponde a um conjunto completo e consistente de tarefas que podem ser, idealmente, escritas, compiladas e testadas individualmente, sendo posteriormente inclu das no programa principal para gerar um arquivo execut avel. Em Fortran h a dois tipos de estruturas que se encaixam nesta categoria: subrotinas e fun c oes (externas ou extr nsecas). Em Fortran 77, havia somente dois tipos de unidades de programas distintas:
Programa principal. Rotinas externas.
Em Fortran 90/95, existem, ao todo, tr es unidades distintas de programa:

Programa principal. Rotinas externas. M odulos.
Cada uma destas unidades de programas ser ao discutidas nas se c oes seguintes. Neste cap tulo (e nos posteriores), os termos rotina (procedure) e sub-programa ser ao usados alternadamente para indicar de forma gen erica tanto subrotinas quanto fun c oes. Outros textos podem vir a tratar estes dois termos como representando entidades ligeiramente distintas.
8.1
Unidades de programa
Tanto em Fortran 77 quanto em Fortran 90/95, um c odigo execut avel e criado a partir de um e somente um programa principal, o qual pode invocar rotinas externas e, no caso do Fortran 90/95, pode usar tamb em m odulos. A u nica unidade de programa que deve necessariamente existir sempre e o programa principal. Com a introdu c ao do Fortran 90/95, quaisquer uma destas tr es unidades de programas podem tamb em invocar rotinas internas, as quais t em estrutura semelhante ` as rotinas externas, por em n ao podem ser testadas isoladamente. Um diagrama ilustrativo das tr es unidades de programas existentes no Fortran 90/95 pode ser visto na gura 8.1. Uma descri c ao mais completa das unidades de programas e dada a seguir.
8.1.1
Programa principal
Todo c odigo execut avel deve ser composto a partir de um, e somente um, programa principal. Opcionalmente, este pode invocar sub-programas. Um programa principal possui a seguinte forma: 79
80
Programa Principal
8.1. Unidades de programa

Modulo
Rotina Externa
Rotina de Modulo Rotina Interna

Figura 8.1: As tr es unidades de programa, as quais podem possuir tamb em rotinas internas.
[PROGRAM <nome do programa> [<declara c~ oes de vari aveis>] [<comandos execut aveis>] [CONTAINS <sub-programas internos> END [PROGRAM [<nome do programa>]] A declara c ao PROGRAM e opcional, por em o seu uso e recomendado.1 O u nico campo n ao opcional na estrutura de um programa, na deni c ao do padr ao da linguagem, e a instru c ao END, a qual possui dois prop ositos: indicar ao compilador que o programa chegou ao m e, quando da execu c ao do c odigo, provoca a parada do mesmo. Nos cap tulos anteriores, j a foram dados v arios exemplos da estrutura do programa principal e, portanto, maiores detalhes n ao s ao necess arios aqui. A declara c ao CONTAINS indica a presen ca de um ou mais sub-programas internos. Estes ser ao descritos em mais detalhes na se c ao 8.2.2. Se a execu c ao do u ltimo comando anterior a CONTAINS n ao provoca um desvio de percurso na execu c ao do programa, atrav es de uma instru c ao GO TO, por exemplo, o controle passa por sobre os sub-programas internos ao comando END e o programa p ara. O comando END pode ser rotulado e ser ent ao atingido por um desvio de execu c ao, como no exemplo ... GO TO 100 ... 100 END PROGRAM em cuja situa c ao o programa tamb em termina. Contudo, este estilo de programa c ao e t pico do Fortran 77, mas n ao e recomendado pelo padr ao do Fortran 90/95. O comando STOP. Outra forma de interromper a execu c ao do programa e atrav es do comando STOP, o qual pode ser rotulado, pode ser parte de um comando ou construto IF e e um comando que pode aparecer no programa principal ou em um sub-programa.
1 No
caso do compilador F, e obrigat orio.
Cap tulo 8. Sub-Programas e M odulos
81
Caso haja v arios comandos STOP em uma mesma unidade, estes podem ser disting uidos por um c odigo de acesso, que se trata de uma constante de caractere ou uma string de at e 5 d gitos. Isto originar a uma mensagem na sa da padr ao indicando o ponto onde a execu c ao foi terminada. A seguir, dois exemplos deste caso: STOP Dados incompletos. STOP 12345 Programa interrompido.
8.1.2
Rotinas externas
Rotinas externas s ao chamadas de dentro de um programa principal ou de outra unidade, usualmente com o intuito de executar uma tarefa bem denida dentro dos objetivos cumpridos pelo programa completo. Rotinas externas s ao escritas em arquivos distintos, separados do arquivo do programa principal. Durante o processo de cria c ao do programa execut avel, estas rotinas podem ser compiladas conjuntamente com o programa principal ou em separado. Nesta u ltima situa c ao, os programas objetos criados durante compila c oes pr evias das rotinas externas s ao linkados junto com o programa objeto do programa principal. Embora seja poss vel colocar-se mais de uma rotina externa no mesmo arquivo, esta pr atica n ao e recomendada.
8.1.3
M odulos
O terceiro tipo de unidade de programa, exclusivo no Fortran 90/95, e o m odulo. Trata-se de uma maneira de se agrupar dados globais, tipos derivados e suas opera c oes associadas, blocos de interface, grupos NAMELIST (se c ao 9.2) e rotinas internas. Tudo associado com uma determinada tarefa pode ser coletado dentro de um m odulo e acessado quando necess ario. Aquelas partes que s ao restritas ao funcionamento interno da tarefa e n ao s ao do interesse direto do programador podem ser feitas invis veis a este, o que permite que o funcionamento interno do m odulo possa ser alterado sem a necessidade de alterar o programa que o usa, prevenindo-se assim altera c ao acidental dos dados. Um m odulo tem a seguinte forma: MODULE <nome m odulo> <declara c~ oes de vari aveis> [CONTAINS <rotinas de m odulo> END [MODULE [<nome m odulo>]] Assim como para END PROGRAM, e recomendado o uso da forma completa do comando END. Uma discuss ao mais extensa acerca dos m odulos em Fortran 90/95 ser a feita na se c ao 8.3.
8.2
Sub-programas
sub-programas podem ser subrotinas ou fun c oes. Como j a foi mencionado, tarefas que podem ser delimitadas por um n umero nito de opera c oes e que devem ser realizadas repetidas vezes durante a execu c ao de um programa devem ser escritas como sub-programas. Uma fun c ao retorna um u nico valor, o qual pode ser um escalar ou uma matriz, e esta usualmente n ao altera os valores de seus argumentos2 . Neste sentido, uma fun c ao em Fortran age como uma fun c ao em an alise matem atica. J a uma subrotina pode executar uma tarefa mais complexa e retornar diversos valores atrav es de seus argumentos, os quais podem ser modicados ao longo da computa c ao da subrotina.
8.2.1
Fun c oes e subrotinas
Exceto pela declara c ao inicial, os sub-programas apresentam uma forma semelhante a de um programa principal. Um sub-programa pode ser uma subrotina: [PURE] [ELEMENTAL] [RECURSIVE] SUBROUTINE <nome subrotina> [(<lista argumentos mudos>)] [<declara c~ oes de vari aveis>]
2 Situa c oes
onde este requisito pode ser relaxado e como estabelecer salvaguardas s ao discutidas na se c ao 8.2.16.
82
8.2. Sub-programas [<comandos execut aveis>] [CONTAINS <sub-programas internos>] END [SUBROUTINE [<nome subrotina>]]
ou pode ser uma fun c ao: [PURE] [ELEMENTAL] [<tipo>] [RECURSIVE] FUNCTION <nome fun c~ ao> & (<lista argumentos mudos>)[RESULT (<nome resultado>)] [<declara c~ oes de vari aveis>] [<comandos execut aveis>] [CONTAINS <sub-programas internos>] END [FUNCTION [<nome fun c~ ao>]] Os diversos constituintes das formas gerais apresentadas acima ser ao discutidos em detalhes nas se c oes seguintes. Por enquanto, ser ao apresentados alguns dos atributos usualmente empregados no campo de <declara c~ oes de vari aveis> de um sub-programa. Al em dos atributos j a vistos, relacionados com as declara c oes de tipo e esp ecie de vari aveis, dos atributos DIMENSION e ALLOCATABLE, os seguintes atributos podem ser usados: INTENT([IN][OUT][INOUT]) OPTIONAL SAVE EXTERNAL INTRINSIC POINTER TARGET A declara c ao CONTAINS cumpre exatamente o mesmo papel cumprido dentro do programa principal. O efeito do comando END em um sub-programa consiste em retornar o controle ` a unidade que o chamou, ao inv es de interromper a execu c ao do programa. Aqui tamb em recomenda-se o uso da forma completa do comando para deixar claro ao compilador e ao programador qual parte do programa est a sendo terminada. Uma fun c ao e ativada ou chamada de forma semelhante como se usa uma fun c ao em an alise matem atica. Por exemplo, dada a fun c ao BESSELJ(n,x), a qual calcula Jn (x), o valor da fun c ao de Bessel do primeiro tipo de ordem n no ponto x. Esta fun c ao pode ser chamada para atribuir seu valor a uma vari avel escalar ou a um elemento de matriz: y= BESSELJ(n,x) sendo que o tipo e esp ecie de y devem, em princ pio, concordar com o tipo e esp ecie do resultado de BESSELJ(n,x). Contudo, caso isto n ao ocorra, valem as regras de convers ao denidas no cap tulo 4. Uma fun c ao pode tamb em fazer o papel de um operando em uma express ao: y= BESSELJ(n,x) + 2*BESSELJ(n,x**2) ou ainda servir de argumento para uma outra rotina. Uma subrotina, devido ao fato de esta retornar, em geral, mais de um valor em cada chamada, n ao pode ser operada como uma fun c ao em an alise matem atica mas deve, isto sim, ser chamada atrav es da instru c ao CALL. Supondo que exista a subrotina BASCARA, a qual calcula as ra zes de um polin omio de segundo grau, x1 e x2, estas ser ao obtidas atrav es da chamada: CALL BASCARA(A0,A1,A2,X1,X2) onde os argumentos da subrotina ser ao discutidos na se c ao 8.2.3 e posteriores. Por exemplo, e poss vel usar-se uma fun c ao como argumento da subrotina: CALL BASCARA(A0,A1,BESSELJ(n,x),x1,x2)
83
8.2.2
Rotinas internas
J a foi observado nas se c oes anteriores que rotinas internas podem ser denidas dentro de quaisquer unidades de programa. Uma rotina interna possui a seguinte estrutura: [RECURSIVE] SUBROUTINE <nome subrotina> [(<lista argumentos mudos>)] [<declara c~ oes de vari aveis>] [<comandos execut aveis>] END SUBROUTINE [<nome subrotina>]] ou [<tipo>] [RECURSIVE] FUNCTION <nome fun c~ ao> (<lista argumentos mudos>) & [RESULT (<nome resultado>)] [<declara c~ oes de vari aveis>] [<comandos execut aveis>] END FUNCTION [<nome fun c~ ao>]] Nota-se agora que as declara c oes FUNCTION e SUBROUTINE agora s ao obrigat orias no comando END. Uma determinada unidade de programa pode conter qualquer n umero de rotinas internas, por em estas, por sua vez, n ao podem conter outras rotinas internas. Cabe aqui uma men c ao a respeito da diferen ca entre uma rotina interna e uma rotina de m odulo. Esta u ltima tamb em e inclu da depois da palavra-chave CONTAINS, em um m odulo, mas pode conter rotinas internas a ela. Uma rotina interna automaticamente tem acesso a todas as entidades do hospedeiro, tais como vari aveis, e possuem tamb em a habilidade de chamar as outras rotinas deste. Contudo, uma determinada rotina interna n ao possui acesso ` as entidades de outra rotina interna. Um exemplo simples do uso de uma fun c ao interna e apresentado a seguir. Note que a vari avel a e declarada no programa principal, tornando-se assim uma vari avel declarada tamb em dentro do ambito da fun c ao calc_a_raiz: program r o t i n t i m p l i c i t none real : : x , a ! print * , Entre com o v a l o r de x : read * , x print * , Entre com o v a l o r de a : read * , a print * , O r e s u l t a d o de a + s q r t ( x ) e: print * , c a l c a r a i z ( x ) print * , O r e s u l t a d o de a + s q r t (1+ x * * 2 ) e: print * , c a l c a r a i z ( 1 . 0 + x * * 2 ) CONTAINS function c a l c a r a i z ( y ) real :: calc a raiz real , intent ( in ) : : y c a l c a r a i z= a + s q r t ( y ) return end function c a l c a r a i z end program r o t i n t No restante deste cap tulo, ser ao descritas v arias propriedades que se aplicam a sub-programas internos, externos e a rotinas de m odulos.
8.2.3
Argumentos de sub-programas
Argumentos de sub-programas fornecem um meio alternativo para que duas unidades de programa compartilhem os mesmos dados. Estes consistem em uma lista de vari aveis escalares ou matriciais, constantes, express oes escalares ou matriciais e at e mesmo os nomes de outras rotinas. Os argumentos de um subprograma s ao muitas vezes denominados vari aveis mudas (dummy variables) . Estes devem coincidir com
84
8.2. Sub-programas
os argumentos transferidos a partir da unidade que chama a rotina em tipo, esp ecie e forma. Contudo, os nomes n ao necessitam ser os mesmos, como se pode ver no exemplo acima. Com base no mesmo exemplo, poder-se-ia realizar duas chamadas da fun c ao calc_a_raiz: ... read*, a,x print*, calc_a_raiz(x) print*, calc_a_raiz(a + x**2) ... Sempre que poss vel, e recomendado que o nome do argumento transferido ao sub-programa seja igual ao nome da vari avel muda. O ponto importante e que sub-programas podem ser escritos de forma independente uns dos outros. A associa c ao das vari aveis mudas com os argumentos verdadeiros ocorrem somente quando a rotina e chamada. Desta forma, bibliotecas de sub-programas podem ser constru dos, possibilitando que estes sejam usados em diferentes programas (ver se c ao 8.2.6). O programa-exemplo bascara1, apresentado na p agina 85, implementa, de forma ing enua, o c alculo das ra zes de um polin omio de segundo grau atrav es da F ormula de B ascara usando uma subrotina interna. Exemplos semelhantes a este ser ao usados para ilustrar o uso de rotinas em outras unidades de programa.
8.2.4
Comando RETURN
No padr ao da linguagem, um sub-programa pode ser encerrado pelo comando END, sendo o controle do uxo retornado ` a unidade que chamou este sub-programa. Contudo, o meio recomendado de se retornar controle a partir de um sub-programa consiste na utiliza c ao do comando RETURN, o qual pode surgir em mais de um ponto da rotina, ao contr ario do END. Como no caso dos comandos STOP e END, o RETURN pode ser rotulado, pode fazer parte de um construto como o IF e e um comando execut avel. O RETURN n ao pode aparecer entre os comandos execut aveis do programa principal.
8.2.5
Atributo e declara c ao INTENT
No programa bascara1, (programa 8.1) as vari aveis mudas a0, a1 e a2 foram utilizadas para transferir ` a subrotina informa c ao acerca dos coecientes do polin omio de 2 grau. Por isto, estes nomes foram declarados ter a inten c ao INTENT(IN). Por outro lado, a subrotina devolveu ao programa os valores das ra zes reais (caso existam) atrav es das vari aveis mudas r1 e r2, as quais foram declaradas ter a inten c ao INTENT(OUT). Uma terceira possibilidade seria a exist encia de uma vari avel cujo valor e inicialmente transferido para dentro da subrotina, modicado por esta e, ent ao transferido para fora da subrotina. Neste caso, esta vari avel deveria ser declarada com a inten c ao INTENT(INOUT). Se uma vari avel muda e especicada com atributo INTENT(IN), o seu valor n ao pode ser alterado pela rotina, seja atrav es de atribui c ao de valor a partir de uma express ao, ou atrav es de sua transfer encia para uma outra rotina que, por sua vez, alteraria este valor. Se a vari avel e especicada com INTENT(OUT), o seu valor e indenido na chamada da rotina, sendo este ent ao denido durante a execu c ao da mesma e nalmente transferido ` a unidade que chamou a rotina. Se a vari avel e especicada com INTENT(INOUT), esta tem o seu valor inicial transferido na chamada da rotina, o valor pode ser alterado e, ent ao, o novo valor pode ser devolvido ` a unidade que chamou a rotina. recomendado que a inten E c ao de todas as vari aveis mudas seja declarada. Em fun c oes, vari aveis mudas somente podem ser declaradas com INTENT(IN). Como alternativa ao uso do atributo INTENT(INOUT), pode-se declarar a inten c ao de nomes de argumentos mudos de rotinas, que n ao sejam sub-programas mudos, atrav es da declara c ao INTENT(INOUT), a qual tem a forma geral: INTENT(<inout>) [::] <lista nomes argumentos mudos> Por exemplo, SUBROUTINE SOLVE(A, B, C, X, Y, Z) REAL :: A, B, C, X, Y, Z INTENT(IN) :: A, B, C INTENT(OUT) :: X, Y, Z ...
85
Programa 8.1: Exemplo de emprego de rotinas internas.
program b a s c a r a 1 i m p l i c i t none logical : : controle real : : a , b , c r e a l : : x1 , x2 ! R a i z e s r e a i s . ! do print * , Entre com o s v a l o r e s dos c o e f i c i e n t e s ( a , b , c ) , print * , onde a * x ** 2 + b * x + c . read * , a , b , c c a l l b a s c a r a ( a , b , c , c o n t r o l e , x1 , x2 ) i f ( c o n t r o l e ) then print * , As r a i z e s ( r e a i s ) s a o : print * , x1= , x1 print * , x2= , x2 e xi t else print * , As r a i z e s s a o complexas . Tente novamente . end i f end do CONTAINS subroutine b a s c a r a ( a2 , a1 , a0 , r a i z e s r e a i s , r1 , r 2 ) ! V a r i a v e i s mudas : real , intent ( in ) : : a0 , a1 , a2 l o g i c a l , intent ( out ) : : r a i z e s r e a i s real , intent ( out ) : : r1 , r 2 ! Variaveis l o ca is : real : : d i s c ! r a i z e s r e a i s= t e s t a d i s c ( a2 , a1 , a0 ) i f ( . not . r a i z e s r e a i s ) return d i s c= a1 * a1 4 * a0 * a2 r 1= 0.5 * ( a1 s q r t ( d i s c ) ) / a2 r 2= 0.5 * ( a1 + s q r t ( d i s c ) ) / a2 return end subroutine b a s c a r a ! function t e s t a d i s c ( c2 , c1 , c0 ) logical : : testa disc ! V a r i a v e i s mudas : real , intent ( in ) : : c0 , c1 , c2 i f ( c1 * c1 4 * c0 * c2 >= 0 . 0 ) then t e s t a d i s c= . t r u e . else t e s t a d i s c= . f a l s e . end i f return end function t e s t a d i s c end program b a s c a r a 1
86
8.2. Sub-programas
8.2.6
Rotinas externas e bibliotecas
Em muitas situa c oes, uma determinada rotina e escrita com o intuito de ser utilizada em diversas aplica c oes distintas. Um exemplo seria uma rotina gen erica que calcula a integral de uma fun c ao qualquer entre dois pontos reais. Nesta situa c ao, e mais interessante manter a rotina como uma entidade distinta do programa principal, para que esta possa ser utilizada por outras unidades de programas. Por isto, uma ou mais rotinas podem ser escritas em um arquivo em separado, constituindo uma unidade de programa pr opria, j a mencionada na se c ao 8.1.2. Esta unidade pode ent ao ser compilada em separado, quando ser a ent ao gerado o programa-objeto correspondente a esta parte do c odigo. Este programa-objeto e ent ao acessado pelo programa linkador para gerar o programa execut avel, ligando a(s) rotina(s) contida(s) nesta unidade com as outras unidades que fazem refer encia ` a(s) mesma(s). O procedimento para realizar esta linkagem e realizado, usualmente, de duas maneiras distintas: 1. O(s) programa-objeto(s) e(s ao) linkado(s) diretamente com as demais unidades de programa. Neste caso, o compilador e o linkador identicam a exist encia do programa-objeto pela sua extens ao, fornecida na linha de comando que demanda a cria c ao do c odigo execut avel. A extens ao de um programa-objeto e usualmente *.o em sistemas operacionais Linux/Unix ou *.obj em sistemas DOS/Windows. 2. O programa-objeto rec em criado e armazenado, inicialmente, em uma biblioteca de programas-objeto criados anteriormente. Ent ao, no momento de se gerar o c odigo execut avel a partir de um programafonte, o linkador e instru do com o nome e o endere co da biblioteca que cont em o(s) programa-objeto(s) da(s) rotina(s) chamadas pelo programa principal e/ou por outras unidades de programas. O linkador procura nesta biblioteca pelos nomes das rotinas invocadas e incorpora o c odigo destas (e somente destas) ao programa execut avel. Com base nesta losoa, o programa bascara1, apresentado na p agina 8.1, pode ser ent ao desmembrado em tr es arquivos distintos, dois contendo a subrotina bascara e a fun c ao testa_disc e um contendo o programa principal bascara2, apresentados na p agina 87. Note o uso do atributo EXTERNAL para indicar que o nome TESTA_DISC consiste em uma fun c ao externa do tipo l ogico.
8.2.7
Interfaces impl citas e expl citas
No exemplo apresentado na p agina 87, o nome testa_disc e identicado como pertencente a uma fun c ao l ogica pelo atributo EXTERNAL: ... LOGICAL, EXTERNAL :: TESTA_DISC ... Caso esta declara c ao n ao fosse realizada, o compilador iria gerar uma mensagem de erro indicando que este nome n ao foi declarado. Uma outra maneira de declarar um nome como pertencente a uma fun c ao externa e usando a declara c ao EXTERNAL, em vez do atributo. Esta e a forma utilizada no Fortran 77. Desta maneira, o mesmo resultado seria obtido atrav es das seguintes linhas: ... LOGICAL :: TESTA_DISC EXTERNAL :: TESTA_DISC ... Au nica diferen ca entre o exemplo acima e o mesmo tipo de declara c ao em um programa Fortran 77 consiste na aus encia dos (::) no u ltimo caso. Em ambas as op c oes anteriores, somente e fornecido ao compilador o nome da fun c ao. Nenhum controle existe sobre os argumentos da fun c ao testa_disc e da subrotina bascara. Por isto, seria poss vel o programa bascara2 chamar a subrotina bascara tentando transferir vari aveis complexas, por exemplo, quando os argumentos mudos da subrotina esperam vari aveis reais. Esta falta de controle, n ao somente quanto ao tipo e esp ecie das vari aveis transferidas a rotinas externas, mas tamb em quanto ao n umero e a ordem dos argumentos, e inerente ao Fortran 77; nenhum mecanismo de controle existe para auxiliar o compilador e o linkador na tarefa de determinar a coer encia entre as diferentes unidades de programas. Para gerar chamadas a sub-programas de forma correta, o compilador necessita conhecer certos detalhes destes sub-programas, como os seus nomes e o n umero, tipo e esp ecie dos argumentos. Em Fortran 90/95, esta tarefa e desempenhada pelos blocos de interface.
Cap tulo 8. Sub-Programas e M odulos ! Chamada p e l a s u b r o t i n a b a s c a r a para t e s t a r s e r a z e s s ao r e a i s . ! function t e s t a d i s c ( c2 , c1 , c0 ) i m p l i c i t none logical : : testa disc ! Varia v e i s mudas : real , intent ( in ) : : c0 , c1 , c2 i f ( c1 * c1 4 * c0 * c2 >= 0 . 0 ) then t e s t a d i s c= . t r u e . else t e s t a d i s c= . f a l s e . end i f return end function t e s t a d i s c ! C a l c u l a as r a z e s r e a i s , c a s o ex is t a m , de um p o l i n o n i o de grau 2 . ! Usa f u n c ao t e s t a d i s c . ! subroutine b a s c a r a ( a2 , a1 , a0 , r a i z e s r e a i s , r1 , r 2 ) i m p l i c i t none ! Varia v e i s mudas : real , intent ( in ) : : a0 , a1 , a2 l o g i c a l , intent ( out ) : : r a i z e s r e a i s real , intent ( out ) : : r1 , r 2 ! Fun c ao e x t e r n a : l o g i c a l , external : : t e s t a d i s c ! Varia veis l o ca i s : real : : d i s c ! r a i z e s r e a i s= t e s t a d i s c ( a2 , a1 , a0 ) i f ( . not . r a i z e s r e a i s ) return d i s c= a1 * a1 4 * a0 * a2 r 1= 0.5 * ( a1 s q r t ( d i s c ) ) / a2 r 2= 0.5 * ( a1 + s q r t ( d i s c ) ) / a2 return end subroutine b a s c a r a ! C a l c u l a as r a z e s r e a i s de um p o l i n o m i o de grau 2 . program b a s c a r a 2 i m p l i c i t none logical : : controle real : : a , b , c r e a l : : x1 , x2 ! R a zes r e a i s . ! do print * , Entre com o s v a l o r e s dos c o e f i c i e n t e s ( a , b , c ) , print * , onde a * x ** 2 + b * x + c . read * , a , b , c c a l l b a s c a r a ( a , b , c , c o n t r o l e , x1 , x2 ) i f ( c o n t r o l e ) then print * , As r a z e s ( r e a i s ) s ao : print * , x1= , x1 print * , x2= , x2 e xi t else print * , As r a z e s s a o complexas . Tente novamente . end i f end do end program b a s c a r a 2
87
88
8.2. Sub-programas
No caso de rotinas intr nsecas, sub-programas internos e m odulos, esta informa c ao e sempre conhecida pelo compilador; por isso, diz-se que as interfaces s ao expl citas. Contudo, quando o compilador chama uma rotina externa, esta informa c ao n ao e conhecida de antem ao e da a interface e dita impl cita. Um bloco de interface, ent ao, fornece a informa c ao necess aria ao compilador. A forma geral de um bloco de interface e: INTERFACE <corpo interface> END INTERFACE Nesta forma, este bloco de interface n ao pode ser nomeado. Assim, a interface deixa de ser impl cita e se torna expl cita. O <corpo interface> consiste das declara c oes FUNCTION ou SUBROUTINE, declara c oes dos tipos e esp ecies dos argumentos dos sub-programas e do comando END FUNCTION ou END SUBROUTINE. Em outras palavras, consiste, normalmente, em uma c opia exata do sub-programa sem seus comandos execut aveis ou rotinas internas, cujas interfaces sempre s ao expl citas. Por exemplo, INTERFACE FUNCTION FUNC(X) REAL :: FUNC REAL, INTENT(IN) :: X END FUNCTION FUNC END INTERFACE Neste exemplo, o bloco fornece ao compilador a interface da fun c ao FUNC. Existe uma certa exibilidade na deni c ao de um bloco de interfaces. Os nomes (mas n ao os tipos e esp ecies) das vari aveis podem ser distintos dos nomes mudos denidos na rotina ou usados na chamada da mesma e outras especica c oes podem ser inclu das, como por exemplo para uma vari avel local ` a rotina. Contudo, rotinas internas e comandos DATA ou FORMAT n ao podem ser inclu dos. Um bloco de interfaces pode conter as interfaces de mais de um sub-programa externo e este bloco pode ser colocado na unidade de programa que chama as rotinas externas ou atrav es do uso de m odulos, como ser a discutido na se c ao 8.3. Em qualquer unidade de programa, o bloco de interfaces e sempre colocado ap os as declara c oes de vari aveis mudas ou de vari aveis locais. Em certas situa c oes, e necess ario fornecer a uma rotina externa o nome de outra rotina externa como um de seus argumentos. Isto pode ser realizado de duas maneiras: 1. Usando o atributo ou declara c ao EXTERNAL, como foi realizado na subrotina bascara, na p agina 8.2.6. 2. Com o uso de um bloco de interface. Neste caso, a interface indicar a ao compilador que um determinado nome consiste, na verdade, no nome de um outro sub-programa. As situa c oes onde isto pode ocorrer s ao discutidas na se c ao 8.2.12 Como exemplo do uso de interfaces expl citas ser a apresentado o programa bascara3, o qual chama novamente as rotinas bascara e testa_disc. Este programa est a listado nas p aginas 89 e 90.
8.2.8
Argumentos com palavras-chave
Argumentos com palavras-chave (keyword arguments) s ao um recurso j a utilizado em comandos de Entrada/Sa da (E/S) no Fortran 77: READ(UNIT= 5, FMT= 101, END= 9000) X,Y,Z onde UNIT, FMT e END s ao as palavras-chave. Elas indicam, respectivamente, o n umero da unidade de acesso para leitura, o r otulo do comando de formato e o r otulo para onde o controle de uxo deve ser desviado quando se atingir o ponto nal de entrada dos dados. Em Fortran 90/95, argumentos com palavras-chave podem ser utilizados n ao somente em comandos de E/S, mas tamb em em rotinas. Quando uma rotina tem diversos argumentos, palavras-chave s ao um excelente recurso para evitar confus ao entre os mesmos. A grande vantagem no uso de palavras-chave est a em que n ao e necess ario lembrar a ordem dos argumentos. Contudo, e necess ario conhecer os nomes dos argumentos mudos denidos no campo de declara c oes da rotina. Por exemplo, dada a seguinte fun c ao interna:
89
! Chamada p e l a s u b r o t i n a b a s c a r a para t e s t a r s e r a z e s s ao r e a i s . ! function t e s t a d i s c ( c2 , c1 , c0 ) i m p l i c i t none logical : : testa disc ! Varia v e i s mudas : real , intent ( in ) : : c0 , c1 , c2 i f ( c1 * c1 4 * c0 * c2 >= 0 . 0 ) then t e s t a d i s c= . t r u e . else t e s t a d i s c= . f a l s e . end i f return end function t e s t a d i s c
! C a l c u l a as r a z e s r e a i s , c a s o ex is t a m , de um p o l i n o n i o de grau 2 . ! Usa f u n c ao t e s t a d i s c . ! subroutine b a s c a r a ( a2 , a1 , a0 , r a i z e s r e a i s , r1 , r 2 ) i m p l i c i t none ! Varia v e i s mudas : real , intent ( in ) : : a0 , a1 , a2 l o g i c a l , intent ( out ) : : r a i z e s r e a i s real , intent ( out ) : : r1 , r 2 ! Varia veis l o ca i s : real : : d i s c INTERFACE function t e s t a d i s c ( c2 , c1 , c0 ) logical : : testa disc real , intent ( in ) : : c0 , c1 , c2 end function t e s t a d i s c END INTERFACE ! r a i z e s r e a i s= t e s t a d i s c ( a2 , a1 , a0 ) i f ( . not . r a i z e s r e a i s ) return d i s c= a1 * a1 4 * a0 * a2 r 1= 0.5 * ( a1 s q r t ( d i s c ) ) / a2 r 2= 0.5 * ( a1 + s q r t ( d i s c ) ) / a2 return end subroutine b a s c a r a
90
8.2. Sub-programas
! C a l c u l a as r a z e s r e a i s de um p o l i n o m i o de grau 2 . program b a s c a r a 3 i m p l i c i t none logical : : controle real : : a , b , c r e a l : : x1 , x2 ! R a zes r e a i s . INTERFACE subroutine b a s c a r a ( a2 , a1 , a0 , r a i z e s r e a i s , r1 , r 2 ) real , intent ( in ) : : a0 , a1 , a2 l o g i c a l , intent ( out ) : : r a i z e s r e a i s real , intent ( out ) : : r1 , r 2 end subroutine b a s c a r a END INTERFACE ! do print * , Entre com o s v a l o r e s dos c o e f i c i e n t e s ( a , b , c ) , print * , onde a * x ** 2 + b * x + c . read * , a , b , c c a l l b a s c a r a ( a , b , c , c o n t r o l e , x1 , x2 ) i f ( c o n t r o l e ) then print * , As r a z e s ( r e a i s ) s ao : print * , x1= , x1 print * , x2= , x2 e xi t else print * , As r a z e s s a o complexas . Tente novamente . end i f end do end program b a s c a r a 3
... CONTAINS FUNCTION AREA(INICIO, FINAL, TOL) REAL :: AREA REAL, INTENT(IN) :: INICIO, FINAL, TOL ... END FUNCTION AREA esta pode ser chamada por quaisquer uma das tr es seguintes atribui c oes: A= AREA(0.0, 100.0, 1.0E-5) B= AREA(INICIO= 0.0, TOL= 1.0E-5, FINAL= 100.0) C= AREA(0.0, TOL= 1.0E-5, FINAL= 100.0) VALOR= 100.0 ERRO= 1.0E-5 D= AREA(0.0, TOL= ERRO, FINAL= VALOR) onde A, B, C e D s ao vari aveis declaradas previamente como reais. Todos os argumentos antes da primeira palavra-chave devem estar ordenados na ordem denida pela fun c ao. Contudo, se uma palavra-chave e utilizada, esta n ao necessita estar na ordem da deni c ao. Al em disso, o valor atribu do ao argumento mudo pode ser uma constante, uma vari avel ou uma express ao, desde que a interface seja obedecida. Depois que uma palavra-chave e utilizada pela primeira vez, todos os argumentos restantes tamb em devem ser transferidos atrav es de palavras-chave. Conseq uentemente, a seguinte chamada n ao e v alida: C= AREA(0.0, TOL= 1.0E-5, 100.0) ! N~ ao e v alido. O exemplo acima n ao e v alido porque tentou-se transferir o valor 100.0 sem haver a informa c ao da palavrachave.
91
Uma vez que o compilador n ao ser a capaz de realizar as associa c oes apropriadas exceto se este conhecer as palavras-chave (nomes dos argumentos mudos), a interface do sub-programa deve ser expl cita caso palavraschave sejam utilizadas. No caso de rotinas internas ou rotinas de m odulo, a interface j a e expl cita. No caso de rotinas externas, faz-se necess ario o uso de um bloco de interfaces.
8.2.9
Argumentos opcionais
Em algumas situa c oes, nem todos os argumentos de um sub-programa necessitam ser transferidos durante uma chamada do mesmo. Um argumento que n ao necessita ser transferido em todas as chamadas poss veis de um sub-programa e denominado opcional. Estes argumentos opcionais podem ser declarados pelo atributo OPTIONAL na declara c ao do tipo de vari aveis. Mantendo o exemplo da fun c ao AREA acima, a seguinte deni c ao pode ser feita: ... CONTAINS FUNCTION AREA(INICIO, FINAL, TOL) REAL :: AREA REAL, INTENT(IN), OPTIONAL :: INICIO, FINAL, TOL ... END FUNCTION AREA a qual agora tem as seguintes chamadas v alidas, entre outras: A= B= C= D= AREA(0.0, 100.0, 1.0E-2) AREA(INICIO= 0.0, FINAL= 100.0, TOL= 1.0E-2) AREA(0.0) AREA(0.0, TOL= 1.0E-2)
onde se fez uso tanto da associa c ao posicional para os valores dos argumentos, quanto da associa c ao via o uso de palavras-chave. Um argumento obrigat orio (que n ao e declarado opcional) deve aparecer exatamente uma vez na lista de argumentos da chamada de uma rotina, ou na ordem posicional ou na lista de palavras-chave. J a um argumento opcional pode aparecer, no m aximo uma vez, ou na lista posicional de argumentos ou na lista de palavras-chave. Da mesma forma como na se c ao 8.2.8, a lista de palavras-chave pode aparecer em qualquer ordem; por em, depois que o primeiro argumento e transferido via uma palavra-chave, todos os restantes, obrigat orios ou opcionais, devem ser transferidos da mesma forma. A rotina necessita de algum mecanismo para detectar se um argumento opcional foi transferido na sua chamada, para que esta possa tomar a medida adequada no caso de presen ca ou de aus encia. Este mecanismo e fornecido pela fun c ao intr nseca PRESENT (se c ao 7.3). Por exemplo, na fun c ao AREA acima, pode ser necess ario vericar a exist encia da vari avel TOL para denir a toler ancia do c alculo ou usar um valor padr ao caso ela n ao tenha sido transferida: ... REAL :: TTOL ... IF(PRESENT(TOL))THEN TTOL= TOL ELSE TTOL= 1.0E-3 END IF ... A vari avel TTOL e utilizada aqui porque ela pode ser redenida, ao passo que a vari avel TOL n ao, uma vez que ela foi declarada com INTENT(IN). Como no caso dos argumento com palavras-chave, se a rotina e externa e possui algum argumento opcional, um bloco de interface deve ser fornecido em algum momento. Este n ao e o caso da fun c ao AREA, uma vez que ela e interna. Contudo se externa ela o fosse, dever-se-ia declarar o seguinte bloco de interface: INTERFACE FUNCTION AREA(INICIO, FINAL, TOL)
92
8.2. Sub-programas REAL :: AREA REAL, INTENT(IN), OPTIONAL :: INICIO, FINAL, TOL END FUNCTION AREA END INTERFACE
8.2.10
Tipos derivados como argumentos de rotinas
Argumentos de rotinas podem ser do tipo derivado se este est a denido em somente uma u nica unidade de programa. Isto pode ser obtido de duas maneiras: 1. A rotina e interna ` a unidade de programa na qual o tipo derivado e denido. 2. O tipo derivado e denido em um m odulo o qual e acessado pela rotina.
8.2.11
Matrizes como argumentos de rotinas
Um outro recurso importante em Fortran e a capacidade de usar matrizes como argumentos mudos de sub-programas. Se um argumento mudo de uma rotina e uma matriz, ent ao o argumento real pode ser:
o nome da matriz (sem subscritos); um elemento de matriz.
A primeira forma transfere a matriz inteira; a segunda forma, a qual transfere somente uma se c ao que inicia no elemento especicado, e descrita em mais detalhes a seguir. 8.2.11.1 Matrizes como argumentos em Fortran 77
O Fortran 77 j a possu a diversos recursos para realizar a transfer encia de matrizes entre sub-programas. Estes recursos foram posteriormente estendidos com a deni c ao do novo padr ao com o Fortran 90/95. O uso mais simples e comum de argumentos mudos matriciais consiste em tornar dispon vel o conte udo completo de uma matriz em uma rotina. Se as matrizes usadas como argumentos reais ser ao todas do mesmo tamanho, ent ao as matrizes mudas na rotina podem usar limites xos (aloca c ao est atica). Por exemplo: SUBROUTINE PROD(X, Y, Z) C Calcula o produto dos vetores X e Y, com 100 elementos cada, C resultando no vetor Z do mesmo tamanho. REAL X(100), Y(100), Z(100) DO 10, I= 1,100 Z(I)= X(I)*Y(I) 15 CONTINUE END Esta subrotina pode ser chamada por um programa semelhante a este: PROGRAM CHAMA_PROD REAL A(100), B(100), C(100) READ(UNIT=*, FMT=*) A,B CALL PROD(A, B, C) WRITE(UNIT=*, FMT=*)C END Este uso de matrizes como argumentos mudos de sub-programas e perfeitamente leg timo, por em inex vel, porque n ao permite o uso de matrizes de qualquer outro tamanho. Para possibilitar uma exibilidade maior, o Fortran 77 introduziu dois mecanismos que possibilitaram uma aloca c ao din amica no tamanho de matrizes usadas como argumentos mudos de sub-programas. Estes mecanismos s ao as matrizes ajust aveis e as matrizes de tamanho assumido. A aloca c ao din amica, entretanto, e parcial, porque as matrizes reais transferidas aos sub-programas deveriam ter seu tamanho denido por aloca c ao est atica em algum ponto dentro das unidades de programas que chamavam as rotinas.
Cap tulo 8. Sub-Programas e M odulos Matrizes ajust aveis
93
Consiste na generaliza c ao dos argumentos matriciais de uma rotina para permitir o uso de matrizes de qualquer tamanho. Neste caso, as express oes inteiras que denem os limites em cada dimens ao das matrizes mudas s ao inclu das nas declara c oes destas dentro da rotina, usando vari aveis inteiras que s ao transferidas junto com as matrizes nos argumentos da rotina ou atrav es do uso de um bloco COMMON (ver se c ao 8.3.1). O exemplo a seguir mostra como isto e realizado: SUBROUTINE PROD(NPTS, X, Y, Z) REAL X(NPTS), Y(NPTS), Z(NPTS) DO 15, I= 1, NPTS ... END Esta subrotina pode ser invocada pela seguinte linha no programa principal ou em outra unidade de programa: CALL PROD(100, A, B, C) as matrizes A, B e C devem ter o seu tamanho alocado de forma est atica nesta ou em alguma outra unidade de programa anterior, conforme j a foi mencionado. O recurso das matrizes ajust aveis pode ser estendido de forma trivial para cobrir o caso de matrizes multi-dimensionais, com limites inferior e superior distintos. Por exemplo, SUBROUTINE MULTI(MAP, K1, L1, K2, L2, TRACO) DOUBLE PRECISION MAP(K1:L1, K2:L2) REAL TRACO(L1-K1+1) Como o exemplo mostra, os limites das dimens oes das matrizes mudas pode ser express oes inteiras envolvendo n ao somente constantes mas tamb em vari aveis inteiras transferidas ` a rotina ou na lista de argumentos ou atrav es de um bloco COMMON. O mecanismo de matrizes ajust aveis pode ser usado para matrizes de qualquer tipo. Uma matriz ajust avel tamb em pode ser transferida a uma outra rotina como um argumento real com, se necess ario, os limites das dimens oes sendo passados de forma concomitante. Matrizes de tamanho assumido Podem haver circunst ancias onde seja impratic avel o uso tanto de matrizes xas quanto de matrizes ajust aveis como argumentos mudos de um sub-programa. A circunst ancia mais freq uente ocorre quando o tamanho real da matriz e desconhecido quando a rotina e inicialmente chamada. Neste caso, uma matriz de tamanho assumido e a alternativa existente em Fortran 77. Estas matrizes tamb em somente s ao permitidas como argumentos mudos de sub-programas, mas neste caso a matriz e, efetivamente, declarada como tendo tamanho desconhecido. Por exemplo: REAL FUNCTION SOMADOIS(TABELA, ANGULO) REAL TABELA(*) N= MAX(1, NINT(SIN(ANGULO)*500.0)) SOMADOIS= TABELA(N) + TABELA(N+1) END Neste caso, a fun c ao somente sabe que a matriz TABELA e unidimensional, com um limite inferior igual a um. Isto e tudo que a fun c ao necessita saber para acessar os elementos apropriados N e N + 1. Ao executar a fun c ao, e responsabilidade do programador assegurar que o valor do ANGULO nunca ir a resultar em um subscrito fora do intervalo correto. Este e sempre um problema quando se usa matrizes de tamanho assumido, porque o compilador n ao tem nenhuma informa c ao a respeito do limite superior da matriz. Uma matriz de tamanho assumido somente pode ter o limite superior de sua u ltima dimens ao especicado por um asterisco; todas as outras dimens oes devem ter seus limites denidos pelas regras usuais ou serem denidos na forma de matrizes ajust aveis.
94 Se c oes de matrizes
8.2. Sub-programas
As regras do Fortran requerem que as extens oes de uma matriz, usada como argumento real de uma rotina, sejam, no m nimo, iguais ` as respectivas extens oes da matriz muda declarada na rotina. Entretanto, a matriz real pode ter extens oes maiores e as regras permitem tamb em uma discord ancia entre os limites inferior e superior das matrizes real e muda. Por exemplo: PROGRAM CONFUS REAL X(-1:50), Y(10:1000) READ(UNIT=*, FMT=*)X, Y CALL SAIDA(X) CALL SAIDA(Y) END C SUBROUTINE SAIDA(MATRIZ) REAL MATRIZ(50) WRITE(UNIT=*,FMT=*)MATRIZ END O resultado deste programa ser a escrever na sa da padr ao inicialmente os elementos X(-1) a X(48), uma vez que este u ltimo coresponde ` a posi c ao na mem oria de MATRIZ(50). Em seguida, o programa escreve Y(10) a Y(59). Esta subrotina ir a funcionar de forma semelhante na se c ao de uma matriz bi-dimensional: PROGRAM DOIS_D REAL D(100,20) ... NFATIA= 15 CALL SAIDA(D(1,NFATIA)) ... Neste exemplo, a se c ao da matriz dos elementos D(1,15) a D(50,15)ser escrita na sa da padr ao. Isto ocorre atrav es da varia c ao dos ndices das linhas, porque esta e a ordem dos elementos de matrizes em Fortran (ver se c ao 6.6.2). O uso de um elemento de matriz como argumento real, quando o argumento mudo da rotina e uma matriz completa consiste uma pr atica que facilmente incorre em erro e, portanto, deve ser evitada. 8.2.11.2 Matrizes como argumentos em Fortran 90/95
Com a deni c ao do novo padr ao Fortran 90/95, os recursos para uso de matrizes como argumentos mudos de sub-programas foi ampliado em rela c ao aos mecanismos j a existentes no Fortran 77. No Fortran 90/95, como j a foi visto na se c ao 6.9, a aloca c ao do tamanho das matrizes pode ser realizada de maneira inteiramente din amica, sendo o espa co na mem oria da CPU alocado em tempo real de processamento. Para fazer uso deste novo recurso, o Fortran 90/95 deniu dois novos mecanismos para a deni c ao de matrizes mudas vari aveis como argumentos de sub-programas: as matrizes de forma assumida, as quais generalizam as matrizes de tamanho assumido do Fortran 77 e os objetos autom aticos, os quais n ao s ao argumentos da rotina, mas tem suas extens oes denidas pelas matrizes mudas desta. Matrizes de forma assumida Novamente como no caso de matrizes ajust aveis ou de tamanho assumido, as formas dos argumentos reais e mudos ainda devem concordar. Contudo, agora uma matriz muda pode assumir a forma (n ao somente o tamanho) da matriz real usada no argumento da rotina. Tal matriz muda e denominada matriz de forma assumida. Quando a forma e declarada com a especica c ao DIMENSION, cada dimens ao tem a sintaxe: [<lim inferior>]: isto e, pode-se denir o limite inferior da dimens ao onde <lim inferior>, no caso mais geral, e uma express ao inteira que pode depender dos outros argumentos da rotina ou de vari aveis globais denidas em m odulos (ou em blocos COMMON, mas o seu uso e desaconselhado no Fortran 90/95). Se <lim inferior> e omitido, o valor padr ao e 1. Deve-se notar que e a forma da matriz que e transferida, n ao os seus limites. Por exemplo:
Cap tulo 8. Sub-Programas e M odulos PROGRAM TESTA_MATRIZ IMPLICIT NONE REAL, DIMENSION(0:10, 0:20) :: A ... CALL SUB_MATRIZ(A) ... CONTAINS SUBROUTINE SUB_MATRIZ(DA) REAL, DIMENSION(:,:), INTENT(INOUT) :: DA ... END SUBROUTINE SUB_MATRIZ END PROGRAM TESTA_MATRIZ
95
A subrotina SUB_MATRIZ declara a matriz de forma assumida DA. A correspond encia entre os elementos da matriz real A e a matriz muda DA e: A(0,0)DA(1,1) . . . A(I,J)DA(I+1,J+1) . . . A(10,20)DA(11,21). Para que houvesse a mesma correspond encia entre os elemento de A e DA, seria necess ario declarar esta u ltima como: REAL, DIMENSION(0:,0:), INTENT(INOUT) :: DA Neste caso, a correspond encia seria a desejada: A(0,0)DA(0,0) . . . A(I,J)DA(I,J) . . . A(10,20)DA(10,20). Para se denir matrizes de forma assumida, e necess ario que a interface seja expl cita na unidade que chama a rotina. A matriz real pode ter sido declarada, na unidade que chama a rotina ou em outra unidade anterior, como uma matriz aloc avel. Como exemplo, considere a seguinte rotina externa, seguida do programa que a chama, programa 8.2, listado na p agina 96: subroutine sub ( ra , rb , rc , max a ) i m p l i c i t none real , dimension ( : , : ) , intent ( in ) real , dimension ( : , : ) , intent ( out ) real , intent ( out ) ! max a= maxval ( r a ) r c= 0 . 5 * rb return end subroutine sub
: : ra , rb : : rc : : max a
Objetos autom aticos Uma rotina com argumentos mudos que s ao matrizes cujos tamanhos variam de uma chamada a outra pode tamb em precisar de matrizes locais (n ao mudas) cujos tamanhos variem ao sabor dos tamanhos das matrizes mudas. Um exemplo simples e a matriz TEMP na subrotina abaixo, destinada a trocar os elementos entre duas matrizes: SUBROUTINE TROCA(A,B) IMPLICIT NONE REAL, DIMENSION(:), INTENT(INOUT) :: A, B REAL, DIMENSION(SIZE(A)) :: TEMP !A fun c~ ao SIZE fornece o tamanho de TEMP. TEMP= A A= B B= TEMP RETURN END SUBROUTINE TROCA Matrizes como a TEMP, cujas extens oes variam da maneira apresentada s ao chamadas matrizes autom aticas e s ao exemplos de objetos autom aticos de dados. Estes s ao objetos de dados cujas declara c oes dependem do valor de express oes n ao-constantes e que n ao s ao argumentos mudos de rotinas. Um outro objeto autom atico, relacionado com vari aveis de caracteres, surge atrav es do comprimento vari avel de um caractere:
96
8.2. Sub-programas
Programa 8.2: Exemplica o uso de matrizes de forma assumida.
program p r o g s u b i m p l i c i t none real , dimension ( 0 : 9 , 1 0 ) : : a real , dimension ( 5 , 5 ) :: c real : : valor max integer : : i INTERFACE subroutine sub ( ra , rb , rc , max a ) real , dimension ( : , : ) , intent ( in ) : : ra , rb real , dimension ( : , : ) , intent ( out ) : : r c real , intent ( out ) : : max a end subroutine sub END INTERFACE ! a= r e s h a p e ( s o u r c e =(/( c o s ( r e a l ( i ) ) , i= 1 , 1 0 0 ) / ) , shape= ( / 1 0 , 1 0 / ) ) c a l l sub ( a , a ( 0 : 4 , : 5 ) , c , valor max ) print * , A m a t r i z a : do i= 0 , 9 print * , a ( i , : ) end do print * , print * , O maior v a l o r em a : , valor max print * , print * , A m a t r i z c : do i= 1 , 5 print * , c ( i , : ) end do end program p r o g s u b
SUBROUTINE EXEMPLO(PALAVRA1) IMPLICIT NONE CHARACTER(LEN= *) :: PALAVRA1 CHARACTER(LEN= LEN(PALAVRA1)) :: PALAVRA2 ... como um exemplo. Se este objeto consiste em uma fun c ao de caractere de tamanho vari avel, a interface deve ser expl cita, como no programa-exemplo loren abaixo. A deni c ao dos limites das dimens oes de um objeto autom atico pode ser realizada tamb em de argumentos mudos ou de vari aveis denidas por associa c ao por uso ou por associa c ao ao hospedeiro. Associa c ao por uso ocorre quando vari aveis globais p ublicas declaradas no corpo de um m odulo s ao disponibilizadas ` a rotina program l o r e n i m p l i c i t none character ( len= * ) , parameter : : a= S o um pequeno exemplo . print * , dobro ( a ) CONTAINS function dobro ( a ) character ( len= * ) , intent ( in ) : : a character ( len= 2 * len ( a )+2) : : dobro dobro= a // // a return end function dobro end program l o r e n
97
atrav es da instru c ao USE; enquanto que associa c ao ao hospedeiro ocorre quando vari aveis declaradas em uma unidade de programa s ao disponibilizadas ` as suas rotinas internas. Matrizes autom aticas s ao automaticamente criadas (alocadas) na entrada da rotina e automaticamente dealocadas na sa da. Assim, o tamanho das matrizes autom aticas pode variar em diferentes chamadas da rotina. Note que n ao h a mecanismo para vericar a disponibilidade de mem oria para a cria c ao de matrizes autom aticas. Caso n ao haja mem oria suciente, o programa e interrompido. Al em disso, uma matriz autom atica n ao pode aparecer em uma declara c ao SAVE (se c ao 8.2.15) ou NAMELIST, ou possuir o atributo SAVE na sua declara c ao. Al em disso, a matriz n ao pode ser inicializada na sua declara c ao. O seguinte programa-exemplo usa matrizes aloc aveis, de forma assumida e autom aticas: subroutine sub mat ( a , r e s ) i m p l i c i t none real , dimension ( : , : ) , intent ( in ) : : a ! M a t r i z de forma assumida real , intent ( out ) : : r e s real , dimension ( s i z e ( a , 1 ) , s i z e ( a , 2 ) ) : : temp ! M a t r i z a u t o m a tica ! temp= s i n ( a ) r e s= minval ( a+temp ) return end subroutine sub mat program m a t r i z a u t i m p l i c i t none real , dimension ( : , : ) , a l l o c a t a b l e : : a real : : res integer : : n , m, i INTERFACE subroutine sub mat ( a , r e s ) real , dimension ( : , : ) , intent ( in ) : : a real , intent ( out ) : : r e s real , dimension ( s i z e ( a , 1 ) , s i z e ( a , 2 ) ) : : temp end subroutine sub mat END INTERFACE print * , Entre com dimens o es da m a t r i z : read * , n ,m a l l o c a t e ( a ( n ,m) ) a= r e s h a p e ( s o u r c e =(/( tan ( r e a l ( i ) ) , i= 1 , n *m) / ) , shape= ( / n ,m/ ) ) print * , Matriz a : do i= 1 , n print * , a ( i , : ) end do c a l l sub mat ( a , r e s ) print * , print * , O menor v a l o r de a + s i n ( a ) e : , res end program m a t r i z a u t
8.2.12
sub-programas como argumentos de rotinas
At e este ponto, os argumentos de uma rotina forma supostos ser vari aveis ou express oes. Contudo, uma outra possibilidade e um ou mais argumentos sendo nomes de outras rotinas que ser ao invocadas. Um exemplo de situa c ao onde e necess ario mencionar o nome de uma rotina como argumento de outra e quando a segunda executa a integra c ao num erica da primeira. Desta forma, e poss vel escrever-se um integrador num erico gen erico, que integra qualquer fun c ao que satisfa ca a interface imposta a ela. Um exemplo de uso do nome de uma rotina como argumento ocorre abaixo. a fun c ao MINIMO calcula o m nimo (menor valor) da fun c ao FUNC em um intervalo: FUNCTION MINIMO(A, B, FUNC) ! Calcula o m nimo de FUNC no intervalo [A,B]. REAL :: MINIMO
98
8.2. Sub-programas REAL, INTENT(IN) :: A, B INTERFACE FUNCTION FUNC(X) REAL :: FUNC REAL, INTENT(IN) :: X END FUNCTION FUNC END INTERFACE REAL :: F,X ... F= FUNC(X) !Invoca c~ ao da fun c~ ao. ... END FUNCTION MINIMO
Note o uso de um bloco de interface para indicar ao compilador que o nome FUNC corresponde a uma fun c ao denida pelo usu ario. Em Fortran 77, como n ao havia o recurso de blocos de interface, a indica c ao que o nome FUNC corresponde a uma fun c ao externa e realizada atrav es da declara c ao EXTERNAL. Assim, no exemplo acima, no lugar da interface apareceria: ... REAL FUNC EXTERNAL FUNC ... para indicar a fun c ao externa. A mesma alternativa continua v alida em Fortran 90/95, onde, al em da declara c ao, pode-se usar tamb em a palavra-chave EXTERNAL como atributo de um nome. Contudo, como j a foi mencionado na se c ao 8.2.7, o simples uso da declara c ao ou atributo EXTERNAL n ao possibilita o controle nos argumentos desta fun c ao, ao contr ario do que ocorre quando a interface e expl cita. Um exemplo de programa que chama a fun c ao MINIMO seria o seguinte: PROGRAM MIN IMPLICIT NONE REAL :: MENOR INTERFACE FUNCTION FUN(X) REAL :: FUN REAL, INTENT(IN) :: X END FUNCTION FUN END INTERFACE ... MENOR= MINIMO(1.0, 2.0, FUN) ... END PROGRAM MIN O uso de um bloco de interface n ao e necess ario se a interface de FUN for expl cita, como no caso de uma rotina de m odulo. No exemplo acima, a fun c ao FUN n ao pode ser interna, porque estas n ao s ao admitidas quando os seus nomes s ao usados como argumentos de outras rotinas. Ou seja, somente rotinas externas ou de m odulos s ao aceitas quando os seus nomes s ao transferidos a outras rotinas como argumentos. O programa-exemplo das p aginas 99 e 100 descreve uma subrotina que gera uma matriz de pontos a partir de uma fun c ao fornecida pelo programador.
8.2.13
Fun co es de valor matricial
Fun c oes, al em de fornecer os resultados usuais na forma de valores dos tipos intr nsecos inteiro, real, complexo, l ogico e de caractere, podem tamb em fornecer como resultado valores de tipo derivado, matrizes e ponteiros. No caso de fun c oes de valor matricial, o tamanho do resultado pode ser determinado de forma semelhante ` a maneira como matrizes autom aticas s ao declaradas. Considere o seguinte exemplo de uma fun c ao de valor matricial:
99
! Usa s u b r o t i n a p l o t a e chama a f u n c a o e x t e r n a Meu F . ! program t e s p l o t a i m p l i c i t none integer : : pts , j real : : yi , y f real , dimension ( : , : ) , a l l o c a t a b l e : : xy INTERFACE subroutine p l o t a ( f , xi , xf , npt , p l o t ) integer , intent ( in ) : : npt real , intent ( in ) : : xi , x f real , dimension ( 2 , npt ) , intent ( out ) : : p l o t INTERFACE function f ( x ) real : : f real , intent ( in ) : : x end function f END INTERFACE end subroutine p l o t a ! function Meu F ( y ) r e a l : : Meu F real , intent ( in ) : : y end function Meu F END INTERFACE ! print * , Entre com o n u mero de p o n t o s : read * , p t s print * , Entre com o s l i m i t e s i n f e r i o r e s u p e r i o r : read * , yi , y f a l l o c a t e ( xy ( 2 , p t s ) ) ! c a l l p l o t a ( Meu F , yi , yf , pts , xy ) ! do j= 1 , p t s print * , xy ( : , j ) end do end program t e s p l o t a
! Fun c a o sen ( exp ( x ) ) . function Meu F ( x ) r e a l : : Meu F real , intent ( in ) : : x ! Meu F= s i n ( exp ( x ) ) return end function Meu F
100
8.2. Sub-programas
! Gera uma m a t r i z de p o n t o s de uma f u n c ao qualquer destinada ` a plotagem ! do g r a f i c o desta fun c ao . ! Par a metros : ! f : Fun c ao e x t e r n a a s e r p l o t a d a . ! x i : Ponto i n i c i a l ( e n t r a d a ) . ! x f : Ponto f i n a l ( e n t r a d a ) . ! npt : N umero de p o n t o s a s e r g e r a d o s ( e n t r a d a ) ! p l o t : m a t r i z de forma (/ npt , 2 /) contendo as a b c i s s a s e ordena da s dos ! p o n t o s ( s a da ). ! subroutine p l o t a ( f , xi , xf , npt , p l o t ) i m p l i c i t none integer , intent ( in ) : : npt real , intent ( in ) : : xi , x f real , dimension ( 2 , npt ) , intent ( out ) : : p l o t INTERFACE function f ( x ) real : : f real , intent ( in ) : : x end function f END INTERFACE ! Varia veis l o ca i s : integer : : i real : : passo , x ! p a s s o= ( x f x i ) / r e a l ( npt 1 ) x= x i do i= 1 , npt p l o t ( 1 , i )= x p l o t ( 2 , i )= f ( x ) x= x + p a s s o end do return end subroutine p l o t a
PROGRAM TES_VAL_MAT IMPLICIT NONE INTEGER, PARAMETER :: M= 6 INTEGER, DIMENSION(M,M) :: IM1, IM2 ... IM2= FUN_VAL_MAT(IM1,1) !Chama fun c~ ao matricial. ... CONTAINS FUNCTION FUN_VAL_MAT(IMA, SCAL) INTEGER, DIMENSION(:,:), INTENT(IN) :: IMA INTEGER, INTENT(IN) :: SCAL INTEGER, DIMENSION(SIZE(IMA,1),SIZE(IMA,2)) :: FUN_VAL_MAT FUN_VAL_MAT= IMA*SCAL END FUNCTION FUN_VAL_MAT END PROGRAM TES_VAL_MAT
Neste exemplo, o limites das dimens oes de FUN_VAL_MAT s ao herdadas do argumento verdadeiro transferido ` fun a c ao e usadas para determinar o tamanho da matriz resultante. Para que o compilador conhe ca a forma da matriz resultante, a interface de uma fun c ao de valor matricial deve ser expl cita em todas as unidades onde esta fun c ao e invocada.
101
8.2.14
Recursividade e rotinas recursivas
Recursividade ocorre quando rotinas chamam a si mesma, seja de forma direta ou indireta. Por exemplo, sejam as rotinas A e B. Recursividade pode ocorrer de duas formas: Recursividade direta: A invoca A diretamente. Recursividade indireta: A invoca B, a qual invoca A. Qualquer cadeia de invoca c oes de rotinas com um componente circular (isto e, invoca c ao direta ou indireta) exibe recursividade. Embora recursividade seja uma t ecnica bonita e sucinta para implementar uma grande variedade de problemas, o uso incorreto da mesma pode provocar uma perda na eci encia da computa c ao do c odigo. Fortran 77 Em Fortran 77, recursividade direta n ao e permitida. Qualquer tentativa de for car uma rotina a chamar a si pr opria resultar a em erro de compila c ao. Em grande parte dos textos, arma-se que recursividade indireta tamb em n ao e poss vel3 . Contudo, recursividade pode ser simulada em Fortran 77 quando uma rotina chama a si pr opria usando n ao o seu nome real mas atrav es de um argumento mudo, como no exemplo abaixo:4 PROGRAM MAIN INTEGER N, X EXTERNAL SUB1 COMMON /GLOBALS/ N X= 0 PRINT*, Entre n umero de repeti c~ oes: READ(*,*) N CALL SUB1(X, SUB1) END PROGRAM MAIN ------------------------------------------SUBROUTINE SUB1(X, SUBMUDO) INTEGER N, X EXTERNAL SUBMUDO COMMON /GLOBALS/ N IF(X .LT. N)THEN X= X + 1 PRINT*, X=, X CALL SUBMUDO(X, SUBMUDO) END IF RETURN END SUBROUTINE SUB1 Como a subrotina SUB1 n ao sabe que ao invocar o argumento mudo SUBMUDO, o qual e o nome de uma rotina externa, vai estar na verdade invocando a si pr opria, o compilador n ao ir a gerar mensagem de erro e o c odigo ir a funcionar em grande parte das plataformas. Por exemplo, se o valor de N for denido igual a 5, o resultado ser a X = 1 X = 2 ... X = 5 o que demonstra que e poss vel simular-se recursividade mesmo em Fortran 77. Fortran 90/95 Em Fortran 90/95, por outro lado, recursividade e suportada como um recurso expl cito da linguagem.
3 Ver, 4 Refer encia:
por exemplo, o texto de Clive Page [5, se ca o 4.3]. Fortran Examples http://www.esm.psu.edu/~ajm138/fortranexamples.html, consultada em 07/06/2005.
102
8.2. Sub-programas
Recursividade direta. Para ns de eci encia na execu c ao do c odigo, rotinas recursivas devem ser explicitamente declaradas usando-se a palavra-chave RECURSIVE SUBROUTINE ... ou RECURSIVE FUNCTION ... A declara c ao de uma fun c ao recursiva e realizada com uma sintaxe um pouco distinta da at e ent ao abordada: uma fun c ao explicitamente declarada recursiva deve conter tamb em a palavra-chave RESULT, a qual especica o nome de uma vari avel ` a qual o valor do resultado do desenvolvimento da fun c ao deve ser atribu do, em lugar do nome da fun c ao propriamente dito. A palavra-chave RESULT e necess aria, uma vez que n ao e poss vel usar-se o nome da fun c ao para retornar o resultado, pois isso implicaria em perda de eci encia no c odigo. De fato, o nome da palavra-chave deve ser usado tanto na declara c ao do tipo e esp ecie do resultado da fun c ao quanto para atribui c ao de resultados e em express oes escalares ou matriciais. Esta palavra-chave pode tamb em ser usada para fun c oes n ao recursivas. Cada vez que uma rotina recursiva e invocada, um conjunto novo de objetos de dados locais e criado, o qual e eliminado na sa da da rotina. Este conjunto consiste de todos os objetos denidos no campo de declara c oes da rotina ou declarados implicitamente, exceto aqueles com atributos DATA ou SAVE (ver se c ao 8.2.15). Fun c oes de valor matricial recursivas s ao permitidas e, em algumas situa c oes, a chamada de uma fun c ao recursiva deste tipo e indisting u vel de uma refer encia a matrizes. O exemplo tradicional do uso de rotinas recursivas consiste na implementa c ao do c alculo do fatorial de um inteiro positivo. A implementa c ao e realizada a partir das seguintes propriedades do fatorial: 0! = 1; N ! = N (N 1)!
A seguir, o c alculo do fatorial e implementado tanto na forma de uma fun c ao quanto na forma de uma subrotina recursivas: RECURSIVE FUNCTION FAT(N) RESULT (N_FAT) IMPLICIT NONE INTEGER :: N_FAT !Define tamb em o tipo de FAT. INTEGER, INTENT(IN) :: N IF(N == 0)THEN N_FAT= 1 ELSE N_FAT= N*FAT(N-1) END IF RETURN END FUNCTION FAT ---------------------------------------------RECURSIVE SUBROUTINE FAT(N, N_FAT) IMPLICIT NONE INTEGER, INTENT(IN) :: N INTEGER, INTENT(INOUT) :: N_FAT IF(N == 0)THEN N_FAT= 1 ELSE CALL FAT(N - 1, N_FAT) N_FAT= N*N_FAT END IF RETURN END SUBROUTINE FAT Recursividade indireta. Uma rotina tamb em pode ser invocada por recursividade indireta, isto e, uma rotina chama outra a qual, por sua vez, invoca a primeira. Para ilustrar a utilidade deste recurso, sup oe-se que se queira realizar uma integra c ao num erica bi-dimensional quando se disp oe somente de um c odigo que executa integra c ao unidimensional. Um exemplo de fun c ao que implementaria integra c ao unidimensional e dado a seguir. O exemplo usa um m odulo, o qual e uma unidade de programa que ser a discutido na se c ao 8.3:
Cap tulo 8. Sub-Programas e M odulos FUNCTION INTEGRA(F, LIMITES) ! Integra F(x) de LIMITES(1) a LIMITES(2). implicit none REAL, DIMENSION(2), INTENT(IN) :: LIMITES INTERFACE FUNCTION F(X) REAL :: F REAL, INTENT(IN) :: X END FUNCTION F END INTERFACE ... INTEGRA= <implementa c~ ao integra c~ ao num erica> RETURN END FUNCTION INTEGRA -------------------------------------------MODULE FUNC IMPLICIT NONE REAL :: YVAL REAL, DIMENSION(2) :: LIMX, LIMY CONTAINS FUNCTION F(XVAL) REAL :: F REAL, INTENT(IN) :: XVAL F= <express~ ao envolvendo XVAL e YVAL> RETURN END FUNCTION F END MODULE FUNC -----------------------------------------FUNCTION FY(Y) ! Integra em X, para um valor fixo de Y. USE FUNC REAL :: FY REAL, INTENT(IN) :: Y YVAL= Y FY= INTEGRA(F, LIMX) RETURN END FUNCTION FY
103
Com base nestas tr es unidades de programa, um programa pode calcular a integral sobre o ret angulo no plano (x, y ) atrav es da chamada: AREA= INTEGRA(FY, LIMY)
8.2.15
Atributo e declara c ao SAVE
A declara c ao ou o atributo SAVE s ao utilizados quando se deseja manter o valor de uma vari avel local em um sub-programa ap os a sa da. Desta forma, o valor anterior desta vari avel est a acess vel quando o sub-programa e invocado novamente. Como exemplo, a subrotina abaixo cont em as vari aveis locais CONTA, a qual conta o n umero de chamadas da subrotina e e inicializada a zero e a vari avel A, que e somada ao valor do argumento. SUBROUTINE CONTA_SOMA(X) IMPICIT NONE REAL, INTENT(IN) :: X REAL, SAVE :: A INTEGER :: CONTA= 0 !Inicializa o contador. ... CONTA= CONTA + 1 IF(CONTA == 1)THEN A= 0.0
Mant em o valor da vari avel.
104 ELSE A= A + X END IF ... RETURN END SUBROUTINE CONTA_SOMA
8.2. Sub-programas
Neste exemplo, tanto a vari avel A quanto CONTA t em o seu valor mantido quando a subrotina e abandonada. Isto e garantido porque a vari avel A e declarada com o atributo SAVE. J a a vari avel CONTA n ao precisa ser declarada com o mesmo atributo porque ela tem o seu valor inicializado na declara c ao. De acordo com o padr ao da linguagem, as vari aveis que t em o seu valor inicializado no momento da declara c ao automaticamente adquirem o atributo SAVE. Alternativamente ao uso do atributo, pode-se declarar uma lista de nomes de vari aveis com a mesma propriedade atrav es da declara c ao SAVE. Desta forma, a vari avel A, no exemplo acima, podia ser declarada atrav es das linhas: ... REAL :: A SAVE :: A ... A forma geral desta declara c ao e: SAVE [[::] <lista nomes vari aveis>] onde uma declara c ao SAVE sem a subseq uente <lista nomes vari aveis> equivale ` a mesma declara c ao aplicada a todos os nomes da rotina, em cujo caso nenhuma outra vari avel pode ser declarada com o atributo SAVE. O atributo SAVE n ao pode ser especicado para um argumento mudo, um resultado de fun c ao ou um objeto autom atico. O atributo pode ser especicado para um ponteiro, em cuja situa c ao seu status de associa c ao e preservado. Pode ser aplicado tamb em a uma matriz aloc avel, em cuja situa c ao o status de aloca c ao e valores s ao preservados. Uma vari avel preservada em um sub-programa recursivo e compartilhada por todas as inst ancias da rotina. O comando ou atributo SAVE podem aparecer no campo de declara c oes de um programa principal, mas neste caso o seu efeito e nulo. O uso pr atico deste recurso est a restrito ` as outras unidades de programa.
8.2.16
Fun co es de efeito lateral e rotinas puras
Na se c ao 8.2, foi mencionado que fun c oes normalmente n ao alteram o valor de seus argumentos. Entretanto, em certas situa c oes esta a c ao e permitida. Fun c oes que alteram o valor de seus argumentos s ao denominadas fun c oes de efeito lateral (side-eect functions) . Para auxiliar na otimiza c ao do c odigo, o padr ao da linguagem estabelece uma proibi c ao no uso de fun c oes de efeito lateral quando o uso de tal fun c ao em uma express ao altera o valor de um outro operando na mesma express ao, seja este operando uma vari avel ou um argumento de uma outra fun c ao. Caso este tipo de fun c ao fosse poss vel neste caso, a atribui c ao RES= FUN1(A,B,C) + FUN2(A,B,C) onde ou FUN1 ou FUN2, ou ambas, alterassem o valor de um ou mais argumentos, a ordem de execu c ao desta express ao seria importante; o valor de RES seria diferente caso FUN1 fosse calculada antes de FUN2 do que seria caso a ordem de c alculo fosse invertida. Exemplos de fun c oes de efeito lateral s ao dados a seguir: FUNCTION FUN1(A,B,C) INTEGER :: FUN1 REAL, INTENT(INOUT) :: A REAL, INTENT(IN) :: B,C A= A*A FUN1= A/B RETURN END FUNCTION FUN1 ----------------------------------Autor: Rudi Gaelzer IFM/UFPel Impresso: 13 de abril de 2010
Cap tulo 8. Sub-Programas e M odulos FUNCTION FUN2(A,B,C) INTEGER :: FUN2 REAL, INTENT(INOUT) :: A REAL, INTENT(IN) :: B,C A= 2*A FUN2= A/C RETURN END FUNCTION FUN2
105
Nota-se que ambas as fun c oes alteram o valor de A; portanto, o valor de RES e totalmente dependente na ordem de execu c ao da express ao. Como o padr ao da linguagem n ao estabelece uma ordem para a execu c ao das opera c oes e desenvolvimentos em uma express ao, este efeito lateral e proibido neste caso. Isto possibilita que os compiladores executem as opera c oes na ordem que otimiza a execu c ao do c odigo. O uso de fun c oes de efeito lateral em comandos ou construtos FORALL (se c ao 6.10), por exemplo, acarretaria em um impedimento severo na otimiza c ao da execu c ao do comando em um processador paralelo, efetivamente anulando o efeito desejado pela deni c ao deste recurso. Para controlar esta situa c ao, o programador pode assegurar ao compilador que uma determinada rotina (n ao somente fun c oes) n ao possui efeitos laterais ao incluir a palavra-chave PURE ` a declara c ao SUBROUTINE ou FUNCTION: PURE SUBROUTINE ... --------------------------PURE FUNCTION ... Em termos pr aticos, esta palavra-chave assegura ao compilador que:
se a rotina e uma fun c ao, esta n ao altera os seus argumentos mudos; a rotina n ao altera nenhuma parte de uma vari avel acessada por associa c ao ao hospedeiro (rotina interna) ou associa c ao por uso (m odulos); a rotina n ao possui nenhuma vari avel local com o atributo SAVE; a rotina n ao executa opera c oes em um arquivo externo; a rotina n ao cont em um comando STOP.
Para assegurar que estes requerimentos sejam cumpridos e que o compilador possa facilmente vericar o seu cumprimento, as seguintes regras adicionais s ao impostas:
qualquer argumento mudo que seja o nome de uma rotina e qualquer rotina invocada devem tamb em ser puras e ter a interface expl cita; as inten c oes de um argumento mudo qualquer devem ser declaradas, exceto se este seja uma rotina ou um ponteiro, e a inten c ao deve sempre ser IN no caso de uma fun c ao; qualquer rotina interna de uma rotina pura tamb em deve ser pura; uma vari avel que e acessada por associa c ao ao hospedeiro ou por uso ou e um argumento mudo de inten c ao IN n ao pode ser o alvo de uma atribui c ao de ponteiro; se a vari avel e do tipo derivado com uma componente de ponteiro, ela n ao pode estar no lado direito de uma atribui c ao e ela n ao pode estar associada como o argumento real de um argumento mudo que seja um ponteiro ou que tenha inten c oes OUT ou INOUT.
Esta u ltima regra assegura que um ponteiro local n ao pode causar um efeito lateral. A principal raz ao para se permitir subrotinas puras est a na possibilidade de seu uso em construtos FORALL. Por em, ao contr ario de fun c oes, uma subrotina pura pode ter argumentos mudos com inten c oes OUT ou INOUT ou atributo POINTER. A sua exist encia tamb em oferece a possibilidade de se fazer chamadas a subrotinas de dentro de fun c oes puras. Uma rotina externa ou muda que seja usada como rotina pura deve possuir uma interface expl cita que a caracterize inequivocamente como tal. Contudo, a rotina pode ser usada em outros contextos sejam o uso de um bloco de interface ou com uma interface que n ao a caracterize como pura. Isto permite que rotinas em bibliotecas sejam escritas como puras sem que elas sejam obrigatoriamente usadas como tal.
106
8.2. Sub-programas
Todas as fun c oes intr nsecas (cap tulo 7) s ao puras e, portanto, podem ser chamadas livremente de dentro de qualquer rotina pura. Adicionalmente, a subrotina intr nseca elemental MVBITS (se c ao 7.9.3) tamb em e pura. O atributo PURE e dado automaticamente a qualquer rotina que seja denida com o atributo ELEMENTAL (se c ao 8.2.17).
8.2.17
Rotinas elementais
Na se c ao 6.7 j a foi introduzida a no c ao de rotinas intr nsecas elementais, as quais s ao rotinas com argumentos mudos escalares que podem ser invocadas com argumentos reais matriciais, desde que os argumentos matriciais tenham todos a mesma forma (isto e, que sejam conform aveis). Para uma fun c ao, a forma do resultado e a forma dos argumentos matriciais. O Fortran 95 estende este conceito a rotinas n ao-intr nsecas. Uma rotina elemental criada pelo programador deve ter um dos seguintes cabe calhos: ELEMENTAL SUBROUTINE ... -------------------------ELEMENTAL FUNCTION ... Um exemplo e fornecido abaixo. Dado o tipo derivado INTERVALO: TYPE :: INTERVALO REAL :: INF, SUP END TYPE INTERVALO pode-se denir a seguinte fun c ao elemental: ELEMENTAL FUNCTION SOMA_INTERVALOS(A,B) INTRINSIC NONE TYPE(INTERVALO) :: SOMA_INTERVALOS TYPE(INTERVALO), INTENT(IN) :: A, B SOMA_INTERVALOS%INF= A%INF + B%INF SOMA_INTERVALOS%SUP= A%SUP + B%SUP RETURN END FUNCTION SOMA_INTERVALOS a qual soma dois intervalos de valores, entre um limite inferior e um limite superior. Nota-se que os argumentos mudos s ao escritos como escalares, mas a especica c ao ELEMENTAL possibilita o uso de matrizes conform aveis como argumentos reais. Neste caso, as opera c oes de soma dos intervalos s ao realizadas componente a componente das matrizes A e B da maneira mais eciente poss vel. Uma rotina n ao pode ser ao mesmo tempo elemental e recursiva. Uma rotina elemental deve satisfazer todos os requisitos de uma rotina pura; de fato, ela j a possui automaticamente o atributo PURE. Adicionalmente, todos os argumentos mudos e resultados de fun c ao devem ser vari aveis escalares sem o atributo POINTER. Se o valor de um argumento mudo e usado em uma declara c ao, especicando o tamanho ou outra propriedade de alguma vari avel, como no exemplo ELEMENTAL FUNCTION BRANCO(N) IMPLICIT NONE INTEGER, INTENT(IN) :: N CHARACTER(LEN= N) :: BRANCO BRANCO= RETURN END FUNCTION BRANCO esta fun c ao deve ser chamada com argumento real escalar, uma vez que um argumento real matricial resultaria em uma matriz cujos elementos seriam caracteres de comprimentos vari aveis. Uma rotina externa elemental deve possuir uma interface expl cita que sempre a caracterize de forma inequ voca como elemental. Isto e exigido para que o compilador possa determinar o mecanismo de chamada que acomode os elementos de matriz de forma mais eciente. Isto contrasta com o caso de uma rotina pura, onde a interface nem sempre necessita caracterizar a rotina como pura. No caso de uma subrotina elemental, se algum argumento real e matriz, todos os argumentos com inten c oes OUT ou INOUT devem ser matrizes. No exemplo abaixo,
Cap tulo 8. Sub-Programas e M odulos ELEMENTAL SUBROUTINE TROCA(A,B) IMPLICIT NONE REAL, INTENT(INOUT) :: A, B REAL :: TEMP TEMP= A A= B B= TEMP RETURN END SUBROUTINE TROCA
107
chamar esta subrotina com um argumento escalar e um matricial est a obviamente errado, uma vez que o mecanismo de distribuir o valor da vari avel escalar por uma matriz conform avel com o outro argumento n ao pode ser aplicado aqui. Se a refer encia a uma rotina gen erica (se c ao 8.3.4) e consistente tanto com uma rotina elemental quanto com uma n ao-elemental, a segunda vers ao e invocada, pois espera-se que a vers ao elemental de uma rotina rode, em geral, mais lentamente. Finalmente, uma rotina elemental n ao pode ser usada como um argumento real de outra rotina.
8.3
M odulos
Uma das novidades mais importantes introduzidas pelo Fortran 90 e um novo tipo de unidade de programa denominada m odulo. Um m odulo e um recurso muito poderoso para transferir dados entre subprogramas e para organizar a arquitetura global de um programa grande e complexo. A funcionalidade de um m odulo pode ser explorada por qualquer unidade de programa que deseja fazer uso (atrav es de uma instru c ao USE) dos recursos disponibilizados por este. Os recursos que podem ser inclu dos em um m odulo s ao os seguintes: Declara c ao de objetos globais. M odulos devem ser empregados no lugar das declara c oes COMMON e INCLUDE, comuns no Fortran 77. Se dados globais s ao necess arios, por exemplo para transferir valores entre rotinas, ent ao estes s ao s ao tornados vis veis sempre que o m odulo e usado. Objetos em um m odulo podem ser inicializados com valores est aticos, de tal forma que estes mant em seu valor em diferentes unidades que usam o mesmo m odulo. Blocos de interfaces. Na maior parte das situa c oes e vantajoso congregar todos os blocos de interfaces em um ou poucos m odulos e ent ao usar o m odulo sempre que uma interface expl cita e necess aria. Isto pode realizado em conjunto com a cl ausula ONLY. Rotinas de m odulos. Rotinas podem ser denidas internamente em um m odulo, sendo estas tornadas acess veis a qualquer unidade de programa que USE o m odulo. Esta estrat egia e mais vantajosa que usar uma rotina externa porque em um m odulo a interface das rotinas internas e sempre expl cita. Acesso controlado a objetos. Vari aveis, rotinas e declara c oes de operadores podem ter a sua visibilidade controlada por declara c oes ou atributos de acesso dentro de um m odulo. Desta forma, e poss vel especicar que um determinado objeto seja vis vel somente no interior do m odulo. Este recurso e freq uentemente utilizado para impedir que um usu ario possa alterar o valor de um objeto de ambito puramente interno ao m odulo. Interfaces gen ericas. Um m odulo pode ser usado para denir um nome gen erico para um conjunto de rotinas, com interfaces distintas, mas que executem todas a mesma fun c ao. Interfaces gen ericas podem ser usadas tamb em para estender a funcionalidade de rotinas intr nsecas. Sobrecarga de operadores. Um m odulo pode ser usado tamb em para redenir a opera c ao executada pelos operadores intr nsecos da linguagem (= + - * / **) ou para denir novos tipos de operadores. Extens ao sem antica. Um m odulo de extens ao sem antica e uma cole c ao de deni c oes de tipos derivados, rotinas e operadores sobrecarregados tais que, quando agregados a uma unidade de programa, permitem que o usu ario use esta funcionalidade estendida como se zesse parte da linguagem padr ao. A forma geral de um m odulo e: MODULE <nome m odulo> <declara c~ oes vari aveis>
108 <comandos execut aveis> [CONTAINS <rotinas de m odulo>] END [MODULE [<nome m odulo>]]
8.3. M odulos
8.3.1
Dados globais
Em Fortran, vari aveis s ao usualmente entidades locais. Contudo, em muitas situa c oes e necess ario que alguns objetos tenham o seu valor compartilhado entre diferentes unidades de programa. A maneira mais usual de se realizar este compartilhamento e atrav es da lista de argumentos de uma rotina. Entretanto, facilmente surge uma situa c ao onde uma vari avel n ao pode ser compartilhada como argumento de um subprograma. Neste momento, e necess aria uma outra estrat egia para se denir dados globais. Esta necessidade j a era corriqueira no Fortran 77. Fortran 77 A maneira mais usada no Fortran 77 para compartilhar dados globais e atrav es de blocos common. Um bloco common e uma lista de vari aveis armazenadas em uma area da mem oria do computador que e identicada atrav es de um nome e que pode ser acessada diretamente em mais de uma unidade de programa. A necessidade de se criar um bloco common surge, muitas vezes, com o uso de rotinas de bibliotecas de aplica c ao generalizada, as quais s ao denidas com um conjunto restrito de argumentos. Muitas vezes, faz-se necess ario transferir informa c ao entre estas rotinas ou entre rotinas que usam as bibliotecas de maneira n ao prevista na lista de argumentos. Por exemplo, seja a subrotina INTEG, a qual realiza a integra c ao num erica unidimensional de uma fun c ao F(x) qualquer, no intervalo (A,B): SUBROUTINE INTEG(F,A,B,RES) REAL*8 A, B, F, RES, TEMP EXTERNAL F ... TEMP= F(X) ... RES= <resultado> END SUBROUTINE INTEG Caso o programador queira integrar a fun c ao g (x) = cos(x) no intervalo [0, 1], ele n ao poder a informar ao integrador o valor de na lista de argumentos da subrotina INTEG. A solu c ao est a no uso de um bloco common: REAL*8 FUNCTION G(X) REAL*8 X, ALFA COMMON /VAR/ ALFA G= COS(ALFA*X) RETURN END FUNCTION G onde VAR e o nome que identica o espa co de mem oria onde o valor de ALFA ser a armazenado. Assim, o programa pode realizar a integra c ao usando o mesmo bloco common: PROGRAM INTEGRA REAL*8 G, A, INT EXTERNAL G COMMON /VAR/ A ... PRINT*, Entre com o valor de alfa: READ(*,*) A C CALL INTEG(G,0.0D0,1.0D0,INT) C ... END PROGRAM INTEGRA
109
Note que o bloco VAR aparece tanto no programa quanto na fun c ao; por em n ao h a necessidade de ele aparecer na subrotina INTEG. A forma geral de um bloco common e: COMMON /<nome common>/ <lista vari aveis> onde <nome common> e qualquer nome v alido em Fortran e <lista vari aveis> e uma lista de vari aveis que podem ser escalares, elementos de matrizes, se c oes de matrizes ou matrizes completas. Neste u ltimo claro que a informa caso, somente se utiliza o nome da matriz. E c ao acerca da natureza e tipo das vari aveis listadas no bloco common deve ser fornecida por declara c oes adequadas de vari aveis. A grande desvantagem desta forma descentralizada de denir-se dados globais est a no fato de que em todas as unidades de programa que utilizam um dado bloco common, as vari aveis listadas nele devem concordar em n umero, ordem, natureza e tipo. Caso o programador esteja desenvolvendo um c odigo complexo, composto por um n umero grande de unidades que usam o mesmo bloco common, e ele sinta a necessidade de alterar de alguma forma a lista de vari aveis em uma determinada unidade, ele dever a buscar em todas unidades restantes que fazem refer encia ao mesmo bloco e realizar a mesma altera c ao; caso contr ario, mesmo que o programa compile e linke sem erro, e quase certo que as vari aveis ser ao compartilhadas de forma inco f erente entre as diferentes unidade de programa e este acabe gerando resultados incorretos. E acil perceber que este controle torna-se sucessivamente mais dif cil ` a medida que a complexidade do programa aumenta. Os blocos common s ao ainda aceitos em Fortran 90/95; por em, o seu uso n ao e recomendado, pela raz ao exposta acima. Fortran 90/95 O uso de um m odulo fornece um mecanismo centralizado de deni c ao de objetos globais. Por exemplo, suponha que se queira ter acesso ` as vari aveis inteiras I, J e K e ` as vari aveis reais A, B e C em diferentes unidades de programa. Um m odulo que permitira o compartilhamento destas vari aveis e o seguinte: MODULE GLOBAIS IMPLICIT NONE INTEGER :: I, J, K REAL :: A, B, C END MODULE GLOBAIS Estas vari aveis se tornam acess veis a outras unidades de programa (inclusive outros m odulos) atrav es da instru c ao USE, isto e: USE GLOBAIS A instru c ao USE e n ao execut avel e deve ser inserida logo ap os o cabe calho da unidade de programa (PROGRAM, FUNCTION, SUBROUTINE ou MODULE) e antes de qualquer outra instru c ao n ao execut avel, tal como uma declara c ao de vari aveis. Uma unidade de programa pode invocar um n umero arbitr ario de m odulos usando uma s erie de instru c oes USE. Um m odulo pode usar outros m odulos, por em um m odulo n ao pode usar a si pr oprio, seja de forma direta ou indireta. Assim, o m odulo GLOBAIS pode ser usado da seguinte forma: FUNCTION USA_MOD(X) USE GLOBAIS IMPLICIT NONE REAL :: USA_MOD REAL, INTENT(IN) :: X USA_MOD= I*A - J*B + K*C - X RETURN END FUNCTION USA_MOD O vantagem de um m odulo sobre um bloco COMMON para compartilhar objetos globais e evidente. A deni c ao dos nomes, tipos e esp ecies das vari aveis e realizada em uma u nica unidade de programa, a qual e simplesmente usada por outras, estabelecendo assim um controle centralizado sobre os objetos. O uso de vari aveis de um m odulo pode causar problemas se o mesmo nome e usado para diferentes vari aveis em partes diferentes de um programa. A declara c ao USE pode evitar este problema ao permitir a especica c ao de um nome local distinto daquele denido no m odulo, por em que ainda permita o acesso aos dados globais. Por exemplo,
110 ... USE GLOBAIS, R => A, S => B ... USA_MOD= I*R - J*S + K*C - X ...
8.3. M odulos
Aqui, os nomes R e S s ao usado para acessar as vari aveis globais A e B, denidas no m odulo, caso estes nomes u ltimos sejam usados para diferentes vari aveis na mesma unidade de programa. Os s mbolos => promovem a liga c ao do nome local com o nome no m odulo. Tudo se passa como se R fosse o apelido de A e S o apelido de B nesta unidade de programa. Os ponteiros em Fortran 90/95 tamb em atuam como apelidos, por em, neste caso, pode-se usar tanto o nome verdadeiro de uma vari avel quanto o nome de um ponteiro que aponta a ela. Existe tamb em uma forma da declara c ao USE que limita o acesso somente a certos objetos dentro de um m odulo. Este recurso n ao e exatamente igual ao uso dos atributos PUBLIC ou PRIVATE (se c ao 8.3.3), uma vez que ele atua somente na unidade que acessa o m odulo, e n ao sobre o m odulo em geral. O recurso requer o uso do qualicador ONLY, seguido de dois pontos : e uma <lista only>: USE <nome m odulo>, ONLY: <lista only> Por exemplo para tornar somente as vari aveis A e C do m odulo GLOBAIS acess veis em uma dada unidade de programa, a declara c ao ca: ... USE GLOBAIS, ONLY: A, C ... Os dois u ltimos recursos podem ser tamb em combinados: ... USE GLOBAIS, ONLY: R => A ... para tornar somente a vari avel A acess vel, por em com o nome R. Uma unidade de programa pode ter mais de uma declara c ao USE referindo-se ao mesmo m odulo. Por conseguinte, deve-se notar que que um USE com o qualicador ONLY n ao cancela uma declara c ao USE menos restritiva. Um uso freq uente de m odulos para armazenar dados globais consiste em deni c oes de par ametros de esp ecie de tipo, constantes universais matem aticas e/ou f sicas e outros objetos est aticos, como no exemplo abaixo: ! *** Module E s p c o n s t *** ! Define e s p e c i e s de t i p o p a d r o es e constantes u n i v e r s a i s . ! M O D U L E esp const ! INTEGER, P A R A M E T E R : : I4B = SELECTED INT KIND ( 9 ) INTEGER, P A R A M E T E R : : I2B = SELECTED INT KIND ( 4 ) INTEGER, P A R A M E T E R : : I1B = SELECTED INT KIND ( 2 ) integer , parameter : : sp= kind ( 1 . 0 ) integer , parameter : : dp= s e l e c t e d r e a l k i n d ( 2 * precision ( 1 . 0 s p ) ) integer , parameter : : qp= s e l e c t e d r e a l k i n d ( 2 * precision ( 1 . 0 dp ) ) complex ( kind= dp ) , parameter : : z1= ( 1 . 0 dp , 0 . 0 dp ) , z i= ( 0 . 0 dp , 1 . 0 dp ) REAL(DP) , P A R A M E T E R : : PI= 3.14159265358979323846264338327950288419717 REAL(DP) , P A R A M E T E R : : PID2= 1.57079632679489661923132169163975144209858 REAL(DP) , P A R A M E T E R : : TWOPI= 6.28318530717958647692528676655900576839434 r e a l ( dp ) , parameter : : r t p i= 1.77245385090551602729816748334114518279755 REAL(DP) , P A R A M E T E R : : SQRT2= 1.41421356237309504880168872420969807856967 r e a l ( dp ) , parameter : : e u l e r e= 2 . 7 1 8 2 8 1 8 2 8 4 5 9 0 4 5 2 3 5 3 6 0 2 8 7 4 7 1 3 5 2 6 6 2 4 9 7 7 5 7 2 5 REAL(SP ) , P A R A M E T E R : : PI S= 3.14159265358979323846264338327950288419717 REAL(SP ) , P A R A M E T E R : : PID2 S= 1 . 5 7 0 7 9 6 3 2 6 7 9 4 8 9 6 6 1 9 2 3 1 3 2 1 6 9 1 6 3 9 7 5 1 4 4 2 0 9 8 5 8 REAL(SP ) , P A R A M E T E R : : TWOPI s= 6 . 2 8 3 1 8 5 3 0 7 1 7 9 5 8 6 4 7 6 9 2 5 2 8 6 7 6 6 5 5 9 0 0 5 7 6 8 3 9 4 3 4 r e a l ( sp ) , parameter : : r t p i s= 1 . 7 7 2 4 5 3 8 5 0 9 0 5 5 1 6 0 2 7 2 9 8 1 6 7 4 8 3 3 4 1 1 4 5 1 8 2 7 9 7 5 5
dp dp dp dp dp dp sp sp sp sp

Programa 8.3: Ilustra uso de m odulo para armazenar dados globais.
111
M O D U L E modu1 i m p l i c i t none real , parameter : : p i= 3 . 1 4 1 5 9 2 6 5 3 6 real , parameter : : e u l e r e= 2 . 7 1 8 2 8 1 8 2 8 END M O D U L E modu1 ! ***************************************** program mod1 use modu1 i m p l i c i t none real : : x do print * , Entre com o v a l o r de x : read * , x print * , s e n ( p i * x)= , s e n ( ) print * , l n ( e * x)= , l n ( ) end do CONTAINS function s e n ( ) real : : sen s e n= s i n ( p i * x ) return end function s e n ! function l n ( ) real : : ln l n= l o g ( e u l e r e * x ) return end function l n end program mod1
REAL(SP ) , P A R A M E T E R : : SQRT2 S= 1 . 4 1 4 2 1 3 5 6 2 3 7 3 0 9 5 0 4 8 8 0 1 6 8 8 7 2 4 2 0 9 6 9 8 0 7 8 5 6 9 6 7 s p ! ! Fundamental p h y s i c a l c o n s t a n t s , o b t a i n e d from NIST : ! h t t p : / / p h y s i c s . n i s t . gov / cuu / C o n s t a n t s / i n d e x . html r e a l ( dp ) , parameter : : rmemp= 5 . 4 4 6 1 7 0 2 1 7 3 e 4 dp ! E l e c t r o n p r o t o n mass r a t i o . r e a l ( dp ) , parameter : : rmpme= 1 8 3 6 . 1 5 2 6 7 2 6 1 dp ! Protron e l e c t r o n mass r a t i o . END M O D U L E esp const O programa-exemplo mod1.f90 (programa 8.3), ilustra o uso de um m odulo para armazenar dados globais.
8.3.2
Rotinas de m odulos
Rotinas podem ser denidas em m odulos e estas s ao denominadas rotinas de m odulos. Estas podem ser tanto subrotinas quanto fun c oes e ter a mesma forma de rotinas internas denidas dentro de outras unidades de programa. O n umero de rotinas de m odulo e arbitr ario. Rotinas de m odulo podem ser chamadas usando o comando CALL usual ou fazendo refer encia ao nome de uma fun c ao. Contudo, estas somente s ao acess veis a unidades de programa que fazem uso do m odulo atrav es da instru c ao USE. Uma rotina de m odulo pode invocar outras rotinas de m odulo contidas no mesmo m odulo. As vari aveis declaradas no m odulo antes da palavra-chave CONTAINS s ao diretamente acess veis a todas as rotinas deste, por associa c ao ao hospedeiro. Contudo, vari aveis declaradas localmente em um determinado sub-programa de m odulo s ao opacas aos outros sub-programas. Caso o m odulo invoque outro m odulo com uma instru c ao USE antes da palavra-chave CONTAINS, estes objetos tamb em se tornam acess veis a todas as rotinas de m odulo. Por outro lado, uma determinada rotina de m odulo pode usar localmente outro m odulo (n ao o
112
8.3. M odulos
hospedeiro), em cuja situa c ao os objetos somente s ao acess veis localmente. Em suma, uma rotina de m odulo possui todas as propriedades de rotinas internas em outras unidades de programa, exceto que uma rotina de m odulo pode conter, por sua vez, rotinas internas a ela. Por exemplo, o seguinte m odulo e v alido: MODULE INTEG IMPLICIT NONE REAL :: ALFA ! Vari avel global. CONTAINS FUNCTION FF(X) REAL :: FF REAL, INTENT(IN) :: X FF= EXP(-ALFA*X*X) FF= FF*X2(X) RETURN CONTAINS FUNCTION X2(Y) REAL :: X2 REAL, INTENT(IN) :: Y X2= Y**2 RETURN END FUNCTION X2 END FUNCTION FF END MODULE INTEG A outra grande diferen ca est a no fato de que as interfaces das rotinas de m odulo s ao expl citas no ambito deste. Todavia, quando uma outra unidade de programa usa o m odulo, todas os objetos p ublicos nele contidos se tornam acess veis a esta, resultando que as interfaces das rotinas de m odulo s ao automaticamente expl citas tamb em para a unidade de programa que o invoca. Portanto, um m odulo e considerado a unidade ideal para armazenar grupos de sub-programas criados para desempenhar uma determinada tarefa, juntamente com os objetos globais associados a estes sub-programas. Ao se compilar um arquivo contendo um m odulo, os compiladores automaticamente geram um novo tipo de arquivo, geralmente com a extens ao *.mod, onde as informa c oes contidas no m odulo, tais como vari aveis globais e interfaces, s ao armazenadas. Quando uma outra unidade de programa faz refer encia a este m odulo, o compilador busca estas informa c oes no arquivo .mod . Desta forma, cria-se um mecanismo para vericar se as vari aveis e as interfaces est ao sendo corretamente utilizadas pela unidade que chama o m odulo. Quando o m odulo n ao dene um rotina interna, n ao e necess ario guardar o arquivo objeto (*.o ou *.obj) associado, bastando guardar o arquivo *.mod. Por esta raz ao, muitos compiladores oferecem uma chave extra de compila c ao atrav es da qual nenhum arquivo objeto e criado, mas somente o arquivo de m odulo. Rotinas de m odulo pode ser u teis por diversas raz oes. Por exemplo, um m odulo que dene a estrutura de um conjunto particular de dados pode tamb em incluir rotinas especiais, necess arias para operar com estes dados; ou um m odulo pode ser usado para conter uma biblioteca de rotinas relacionadas entre si. Como exemplo, um m odulo pode ser usado para adicionar vari aveis de tipo derivado: MODULE MOD_PONTO IMPLICIT NONE TYPE :: PONTO REAL :: X, Y END TYPE PONTO CONTAINS FUNCTION ADPONTOS(P,Q) TYPE(POINT) :: ADPONTOS TYPE(POINT), INTENT(IN) :: P, Q ADPONTOS%X= P%X + Q%X ADPONTOS%Y= P%Y + Q%Y RETURN END FUNCTION ADPONTOS END MODULE MOD_PONTO Neste caso, o programa principal usa este m odulo:

Programa 8.4: Ilustra o uso de rotinas de m odulo.
113
M O D U L E modu2 i m p l i c i t none real , parameter : : p i= 3 . 1 4 1 5 9 2 6 5 3 6 real , parameter : : e u l e r e= 2 . 7 1 8 2 8 1 8 2 8 real : : x CONTAINS function s e n ( ) real : : sen s e n= s i n ( p i * x ) return end function s e n ! function l n ( ) real : : ln l n= l o g ( e u l e r e * x ) return end function l n END M O D U L E modu2 ! ***************************************** program mod2 use modu2 i m p l i c i t none do print * , Entre com o v a l o r de x : read * , x print * , s e n ( p i * x)= , s e n ( ) print * , l n ( e * x)= , l n ( ) end do end program mod2
PROGRAM P_PONTO USE MOD_PONTO IMPLICIT NONE TYPE(POINT) :: PX, PY, PZ ... PZ= ADPONTO(PX,PY) ... END PROGRAM P_PONTO O recurso avan cado de sobrecarga de operador (operator overloading) permite redenir a opera c ao de adi c ao (+), por exemplo, dentro do ambito do m odulo M_PONTO, de tal forma que o processo de adi c ao de duas vari aveis do tipo PONTO automaticamente iria chamar a fun c ao ADPONTO. Desta forma, ao inv es do programa chamar esta fun c ao, bastaria realizar a opera c ao: PZ= PX + PY Entretanto, este recurso n ao ser a discutido aqui. O programa-exemplo mod2.f90 (programa 8.4) e igual ao mod1.f90, por em usando rotinas de m odulo.
8.3.3
Atributos e declara c oes PUBLIC e PRIVATE
Usualmente, todas as entidades em um m odulo est ao dispon veis para qualquer unidade de programa que chame este m odulo com a instru c ao USE. Contudo, em certas situa c oes e recomend avel proibir o uso de certas entidades (objetos globais e/ou rotinas) contidas no m odulo para for car o usu ario a invocar as
114
8.3. M odulos
rotinas de m odulo que realmente deveriam ser acess veis a este, ou para permitir exibilidade no aperfei coamento das entidades contidas no m odulo sem haver a necessidade de informar o usu ario a respeito destes aperfei coamentos. Este controle e exercido atrav es dos atributos ou declara c oes PUBLIC ou PRIVATE. Por exemplo, abaixo temos a declara c oes de vari aveis com dois atributos distintos: REAL, PUBLIC :: X, Y, Z INTEGER, PRIVATE :: U, V, W Dentro deste conjunto de vari aveis, somente X, Y e Z s ao acess veis ` a unidade de programa que acessa este m odulo. Outra maneira de se estabelecer o controle de acesso e atrav es de declara co es, as quais listam os nomes dos objetos que s ao p ublicos ou privados: PUBLIC :: X, Y, Z PRIVATE :: U, V, W A forma geral da declara c ao e: PUBLIC [[::] <lista acesso>] PRIVATE [[::] <lista acesso>] Caso nenhum controle e estabelecido em um m odulo, seja atrav es de um atributo ou de uma declara c ao, todas as entidades t em o atributo PUBLIC. Se uma declara c ao PUBLIC ou PRIVATE n ao possui uma lista de entidades, esta conrma ou altera o acesso padr ao. Assim, a declara c ao PUBLIC conrma o acesso padr ao, ao passo que a declara c ao PRIVATE altera o acesso padr ao. Desta forma, uma seq u encia de declara c oes como as abaixo: ... PRIVATE PUBLIC <lista acesso> ... confere aos nomes na <lista acesso> o atributo PUBLIC enquanto que todas as entidades restantes no m odulo s ao privadas, podendo ser acessadas somente dentro do ambito do m odulo.
8.3.4
Interfaces e rotinas gen ericas
Outro recurso poderoso introduzido pelo Fortran 90 e a habilidade do programador denir suas pr oprias rotinas gen ericas, de tal forma que um u nico nome e suciente para invocar uma determinada rotina, enquanto que a a c ao que realmente e executada quando este nome e usado depende do tipo de seus argumentos. Embora possam ser declaradas em quaisquer unidades de programa, rotinas gen ericas s ao usualmente denidas em m odulos. Uma rotina gen erica e denido usando-se um bloco interfaces e um nome gen erico e usado para todas as rotinas denidas dentro deste bloco de interfaces. Assim, a forma geral e: INTERFACE <nome gen erico> <bloco interface rotina espec fica 1> <bloco interface rotina espec fica 2> ... END INTERFACE <nome gen erico> onde <bloco interface rotina espec fica 1>, etc, s ao os blocos das interfaces das rotinas espec cas, isto e, que se referem a um dado conjunto de tipos de vari aveis, e que s ao acessadas atrav es do <nome gen erico>. As rotinas per se podem se encontrar em outras unidades; por exemplo, elas podem ser rotinas externas. O uso do <nome gen erico> no nal do bloco somente e permitido a partir do Fortran 95. Como um m odulo e a unidade de programa ideal para armazenar todas estas rotinas espec cas relacionadas entre si e como as interfaces das rotinas de m odulo s ao sempre expl citas, estas rotinas gen ericas s ao, em geral, denidas dentro de m odulos. Neste caso, a declara c ao
Cap tulo 8. Sub-Programas e M odulos MODULE PROCEDURE <lista nomes rotinas>
115
e inclu da no bloco de interface para nomear as rotinas de m odulo que s ao referidas atrav es do nome gen erico. Assim, a declara c ao geral e: INTERFACE <nome gen erico> [<blocos interfaces>] [MODULE PROCEDURE <lista nomes rotinas>] ! Em Fortran 95 blocos de interfaces e declara c~ oes MODULE PROCEDURE ! podem aparecer em qualquer ordem. END INTERFACE [<nome gen erico>] ! Somente em Fortran 95 o nome gen erico e aceito aqui. Deve-se notar que todos os nomes na <lista nomes rotinas> devem ser de rotinas de m odulo acess veis; portanto, elas n ao necessariamente devem estar denidas no mesmo m odulo onde a interface gen erica e estabelecida, bastando que elas sejam acess veis por associa c ao de uso. Para demonstrar o poderio de uma interface gen erica, ser a utilizada novamente a subrotina TROCA, a qual foi denida primeiramente na p agina 95 e depois, na forma de uma subrotina elemental, na se c ao 8.2.17. O m odulo gentroca na p agina 116 dene o nome gen erico de uma s erie de subrotinas elementais TROCA associadas a vari aveis dos tipos real, inteiro, l ogico e do tipo derivado ponto, o qual e denido no mesmo m odulo. Este m odulo e utilizado ent ao em duas situa c oes distintas. Na primeira vez, o m odulo ser a utilizado para agina trocar o valor de duas vari aveis escalares do tipo ponto, como no programa usa gentroca.f90 na p 117. Posteriormente, o mesmo m odulo ser a utilizado para trocar os elementos de duas matrizes inteiras, como no programa usa_gt_mat.f90, tamb em listado na p agina 117.
Uma declara c ao MODULE PROCEDURE somente e permitida se um <nome gen erico> e fornecido. Por em, o nome gen erico pode ser igual ao nome de uma das rotinas declaradas na <lista nomes rotinas>. Em conjunto com esta propriedade, o nome gen erico denido em um m odulo pode ser o mesmo de outro nome gen erico acess vel ao m odulo, inclusive no caso onde o nome gen erico corresponde ao de uma rotina intr nseca. Neste caso, o m odulo estar a estendendo o intervalo de aplica c ao de uma rotina intr nseca. As rotinas ` as quais s ao dadas um certo nome gen erico devem ser todas ou subrotinas ou fun c oes, incluindo as intr nsecas quando uma rotina intr nseca e estendida. Quaisquer duas rotinas n ao-intr nsecas associadas ao mesmo nome gen erico devem ter argumentos que diferem de tal forma que qualquer invoca c ao e feita de forma inequ voca. As regras s ao que: 1. uma delas tenha mais argumentos obrigat orios mudos de um tipo, esp ecie e posto particulares que a outra ou 2. que ao menos uma delas tenha um argumento mudo obrigat orio tal que (a) corresponda por posi c ao na lista de argumentos a um argumento mudo que n ao esteja presente na outra, ou esteja presente com um tipo e/ou esp ecie distinta ou com posto distinto, e (b) corresponda por nome a um argumento mudo que n ao esteja presente na outra, ou presente com tipo e/ou esp ecie diferente ou com posto diferente. Para o caso (2), ambas as regras s ao necess arias para descartar a possibilidade de invoca c ao amb gua por uso de palavras-chave. Como exemplo onde haver a ambig uidade, o exemplo abaixo: !Exemplo de defini c~ ao amb gua de nome gen erico INTERFACE F MODULE PROCEDURE FXI, FIX END INTERFACE F CONTAINS FUNCTION FXI(X,I) REAL :: FXI REAL, INTENT(IN) :: X INTEGER, INTENT(IN) :: I ...
116
8.3. M odulos
! D e f i n e nome g e n e r i c o para t r o c a de duas v a r i aveis quaisquer . M O D U L E gentroca i m p l i c i t none type : : ponto real : : x , y end type ponto ! INTERFACE t r o c a M O D U L E PROCEDURE t r o c a p o n t o , t r o c a r e a l , t r o c a i n t , t r o c a l o g END INTERFACE t r o c a ! CONTAINS e l e m e n t a l subroutine t r o c a p o n t o ( a , b ) type ( ponto ) , intent ( inout ) : : a , b type ( ponto ) : : temp temp= a a= b b= temp end subroutine t r o c a p o n t o ! e l e m e n t a l subroutine t r o c a r e a l ( a , b ) real , intent ( inout ) : : a , b r e a l : : temp temp= a a= b b= temp end subroutine t r o c a r e a l ! e l e m e n t a l subroutine t r o c a i n t ( a , b ) integer , intent ( inout ) : : a , b integer : : temp temp= a a= b b= temp end subroutine t r o c a i n t ! e l e m e n t a l subroutine t r o c a l o g ( a , b ) l o g i c a l , intent ( inout ) : : a , b l o g i c a l : : temp temp= a a= b b= temp end subroutine t r o c a l o g END M O D U L E gentroca
Cap tulo 8. Sub-Programas e M odulos program u s a g e n t r o c a use g e n t r o c a type ( ponto ) : : b= ponto ( 1 . 0 , 0 . 0 ) , c= ponto ( 1 . 0 , 1 . 0 ) print * , V a l o r e s o r i g i n a i s : print * , b , c call troca (b , c ) print * , Novos v a l o r e s : print * , b , c end program u s a g e n t r o c a
117
program u s a g t m a t use g e n t r o c a integer , dimension ( 2 , 2 ) : : b , b= r e s h a p e ( s o u r c e= ( / ( ( i+j , c= r e s h a p e ( s o u r c e= ( / ( ( i+j , print * , V a l o r e s o r i g i n a i s : do i= 1 , 2 print * , b ( i , : ) , ,c(i end do call troca (b , c ) print * , Novos v a l o r e s : do i= 1 , 2 print * , b ( i , : ) , ,c(i end do end program u s a g t m a t
c i= 1 , 2 ) , j= 1 , 2 ) / ) , shape= ( / 2 , 2 / ) ) i= 3 , 4 ) , j= 3 , 4 ) / ) , shape= ( / 2 , 2 / ) )
,:)
,:)
END FUNCTION FXI ! FUNCTION FIX(I,X) REAL :: FIX REAL, INTEN(IN) :: X INTEGER, INTENT(IN) :: I ... END FUNCTION FIX Neste caso, a chamada ao nome gen erico F ser a n ao-amb gua no caso de argumentos posicionais: A= F(INT,VAR) por em ser a amb gua para chamada usando palavras-chave: A= F(I= INT, X= VAR) Se uma invoca c ao gen erica e amb gua entre uma rotina intr nseca e uma n ao-intr nseca, esta u ltima e sempre invocada.
8.3.5
Estendendo rotinas intr nsecas via blocos de interface gen ericos
Como j a foi mencionado, uma rotina intr nseca pode ser estendida ou tamb em redenida. Uma rotina intr nseca estendida suplementa as rotinas intr nsecas espec cas j a existentes. Uma rotina intr nseca redenida substitui uma rotina intr nseca espec ca existente. Desta forma e poss vel ampliar um determinado c alculo de uma fun c ao, por exemplo, para interfaces n ao previstas pelo padr ao da linguagem (extens ao ) e/ou substituir o processo de c alculo do valor da fun c ao por um c odigo distinto daquele implementado no compilador (substitui c ao ). Quando um nome gen erico e igual ao nome gen erico de uma rotina intr nseca e o nome e declarado com o atributo ou declara c ao INTRINSIC (ou aparece em um contexto intr nseco), a interface gen erica estende a rotina gen erica intr nseca.
118
8.4. Ambito (Scope)
Quando um nome gen erico e igual ao nome gen erico de uma rotina intr nseca e este nome n ao possui o atributo INTRINSIC (nem possui este atributo pelo contexto), a rotina gen erica redene a rotina gen erica intr nseca. Como exemplo, o m odulo EXT_SINH abaixo estende o c alculo da fun c ao seno hiperb olico para um argumento escalar complexo, enquanto que o padr ao da linguagem somente considera argumentos reais (se c ao 7.5): MODULE EXT_SINH IMPLICIT NONE INTRINSIC :: SINH ! INTERFACE SINH MODULE PROCEDURE SINH_C END INTERFACE SINH ! CONTAINS FUNCTION SINH_C(Z) COMPLEX :: SINH_C COMPLEX, INTENT(IN) :: Z REAL :: X,Y X= REAL(Z) Y= AIMAG(Z) SINH_C= CMPLX(SINH(X)*COS(Y),COSH(X)*SIN(Y)) RETURN END FUNCTION SINH_C END MODULE EXT_SINH
8.4
Ambito (Scope)
J a foi mencionado neste texto, em diversos lugares, o ambito de um certo nome de vari avel. O ambito de um objeto nomeado ou de um r otulo e o conjunto de unidades de a mbito, que n ao se sobrep oe, onde o nome deste objeto pode ser usado sem ambig uidade. Uma unidade de ambito e qualquer um dos seguintes:
uma deni c ao de tipo derivado; o corpo de um bloco de interfaces de rotinas, excluindo quaisquer deni c oes de tipo derivado e blocos de interfaces contidos dentro deste, ou uma unidade de programa ou sub-programa, excluindo deni c oes de tipo derivado, blocos de interfaces e rotinas internas contidas dentro desta unidade.
8.4.1
Ambito dos r otulos
Toda unidade de programa ou sub-programa, interno ou externo, tem seu conjunto independente de r otulos. Portanto, o mesmo r otulo pode ser usado em um programa principal e em seus sub-programas internos sem ambig uidade. Assim, o ambito de um r otulo e um programa principal ou sub-programa, excluindo quaisquer subprogramas internos que eles contenham. O r otulo pode ser usado sem ambig uidade em qualquer ponto entre os comandos execut aveis de seu ambito.
8.4.2
Ambito dos nomes
O ambito de um nome declarado em uma unidade de programa estende-se do cabe calho da unidade de programa ao seu comando END. O ambito de um nome declarado em um programa principal ou rotina externa estende-se a todos os sub-programas que eles cont em, exceto quando o nome e redeclarado no sub-programa. O ambito de um nome declarado em uma rotina interna e somente a pr opria rotina, e n ao os outros sub-programas internos. O ambito do nome de um sub-programa interno e do n umero e tipos dos seus argumentos estende-se por toda a unidade de programa que o cont em, inclusive por todos os outros subprogramas internos.
119
O ambito de um nome declarado em um m odulo estende-se a todas as unidades de programa que usam este m odulo, exceto no caso em que a entidade em quest ao tenha o atributo PRIVATE, ou e renomeada na unidade de programa que usa o m odulo ou quando a instru c ao USE apresenta o qualicador ONLY e a entidade em quest ao n ao esteja na <lista only>. O ambito de um nome declarado em um m odulo estende-se a todos os sub-programas internos, excluindo aqueles onde o nome e redeclarado. Considerando a deni c ao de unidade de ambito acima,
Entidades declaradas em diferentes unidades de ambito s ao sempre distintas, mesmo que elas tenham o mesmo nome e propriedades. Dentro de uma unidade de ambito, cada entidade nomeada deve possuir um nome distinto, com a exce c ao de nomes gen ericos de rotinas. Os nomes de unidades de programas s ao globais; assim, cada nome deve ser distinto dos outros e distinto de quaisquer entidades locais na unidade de programa. O ambito do nome de uma rotina interna estende-se somente por toda a unidade de programa que a cont em. O ambito de um nome declarado em uma rotina interna e esta rotina interna.
Este conjunto de regras resume a deni c ao de ambito de um nome. Nomes de entidades s ao acess veis por associa c ao ao hospedeiro ou associa c ao por uso quando: Associa c ao ao hospedeiro. O ambito de um nome declarado em uma unidade de programa estende-se do cabe calho da unidade de programa ao comando END. Associa c ao por uso. O a mbito de um nome declarado em um m odulo, o qual n ao possui o atributo PRIVATE, estende-se a qualquer unidade de programa que usa o m odulo. Nota-se que ambos os tipos de associa ca o n ao se estende a quaisquer rotinas externas que possam ser invocadas e n ao incluem quaisquer rotinas internas onde o nome e redeclarado. Um exemplo contendo 5 unidades de ambito e ilustrado a seguir: MODULE AMBITO1 ... CONTAINS SUBROUTINE AMBITO2 TYPE :: AMBITO3 ... END TYPE AMBITO3 INTERFACE ... END INTERFACE ... CONTAINS FUNCTION AMBITO5(...) ... END FUNCTION AMBITO5 END SUBROUTINE AMBITO2 END MODULO AMBITO1 ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito Ambito 1 1 1 2 3 3 3 2 4 2 2 2 5 5 5 2 1
120
8.4. Ambito (Scope)
Cap tulo 9
Comandos de Entrada/Sa da de Dados

O Fortran 90/95 possui um conjunto rico de instru c oes de entrada/sa da (E/S) de dados. Entretanto, este cap tulo ir a apresentar apenas um conjunto de instru c oes que implementam um processo b asico de E/S. Muitos programas necessitam de dados iniciais para o seu processamento. Depois que os c alculos estiverem completos, os resultados naturalmente precisam ser impressos, mostrados gracamente ou salvos para uso posterior. Durante a execu c ao de um programa, algumas vezes h a uma quantidade grande de dados produzidos por uma parte do programa, os quais n ao podem ser todos armazenados na mem oria de acesso aleat orio (RAM) do computador. Nesta situa c ao tamb em se usam os comandos de E/S da linguagem. O Fortran 90/95 possui muitos comandos de E/S. Os mais utilizados s ao:
OPEN READ WRITE PRINT CLOSE REWIND BACKSPACE
estes comandos est ao todos embutidos dentro da linguagem a qual possui, adicionalmente, recursos de formata c ao que instruem a maneira como os dados s ao lidos ou escritos. At e este ponto, todos os exemplos abordados executaram opera c oes de E/S de dados com teclado (entrada) e terminal (sa da). Adicionalmente, Fortran 90/95 permite que diversos outros objetos, como arquivos de dados, estejam conectados a um programa para leitura e/ou escrita. Neste cap tulo, ser ao abordados os processos de E/S em arquivos de dados, por ser este o uso mais freq uente deste recurso. Outros tipos de usos incluem sa da direta de dados em impressoras, plotters, programas gr acos, recursos de multimeios, etc. Devido ` a variedade de usos dos comandos de E/S, e interessante que se fa ca inicialmente uma introdu c ao simples ao assunto, abordando os usos mais freq uentes dos processos com arquivos externos, para posteriormente entrar-se em maiores detalhes. Com este intuito, a se c ao 9.1 cont em esta introdu c ao r apida, ao passo que as se c oes posteriores (9.3 9.11) abordam o assunto de uma forma bem mais abrangente.
9.1
Comandos de Entrada/Sa da: introdu c ao r apida
Na se c ao 2.3 na p agina 11 j a foram apresentadas a entrada (teclado) e a sa da (tela do monitor) padr oes do Fortran. Usado desta forma, o recurso e demasiado limitado. O programador possui controle muito restrito, por exemplo, sobre onde, na tela, o resultado deve ser apresentado e sobre o n umero de casas decimais que deve ser utilizado para representar o valor. Adicionalmente, o programador est a limitado ao teclado para o fornecimento de par ametros ao programa. Um uso mais desej avel dos recursos de E/S do Fortran consiste na habilidade de ler e gravar dados, por exemplo, em arquivos residentes no disco r gido do computador ou em outra m dia ` a qual o mesmo tem 121
122
9.1. Comandos de Entrada/Sa da: introdu c ao r apida
acesso. Nesta se c ao, o acesso de E/S a arquivos ser a brevemente discutido na forma de tarefas atribu das ao programador.
Tarefa 1. Sa da formatada na tela do monitor

Considera-se inicialmente o seguinte programa que realiza sa da no formato livre na tela: program F out i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) r e a l ( dp ) : : a , b , c a= 1 . 0 dp / 7 . 0 dp b= s q r t ( 2 . 0 dp ) c= 4 * atan ( 1 . 0 dp ) print * , a , b , c end program F out Os resultados deste programa s ao apresentados da seguinte maneira na tela do monitor: 0.142857142857143 1.41421356237310 3.14159265358979
Observa-se que h a um n umero grande de espa cos em branco antes e entre os valores dos resultados e todos s ao apresentados com o n umero total de d gitos represent aveis para uma vari avel real de dupla precis ao. O programa a seguir apresenta os mesmos resultados, por em de maneiras mais organizadas: program F o u t f o r m a t a d o i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) r e a l ( dp ) : : a , b , c a= 1 . 0 dp / 7 . 0 dp b= s q r t ( 2 . 0 dp ) c= 4 * atan ( 1 . 0 dp ) print ( f 7 . 5 , 1 x , f 9 . 7 , 1 x , f 1 1 . 9 ) , a , b , c print ( f 7 . 7 , 1 x , f 9 . 9 , 1 x , e11 . 5 ) , a , b , c print ( a= , f 7 . 5 , 2 x , b= , f 9 . 7 , 3 x , c= , f 1 1 . 9 ) , a , b , c end program F o u t f o r m a t a d o Agora, os resultados s ao: 0.14286 1.4142136 3.141592654 ******* ********* 0.31416 E +01 a = 0.14286 b = 1.4142136 c = 3.141592654 Nos tr es resultados, o segundo argumento dos comandos WRITE indica a formata c ao na sa da, conforme determinada pelo especicador FMT=,1 o qual n ao e obrigat orio se o formato dos dados aparecer como segundo elemento de um comando de E/S. A formata c ao dos dados de sa da e determinada pela seq u encia de descritores de edi c ao (X, F e E), os quais t em os seguintes signicados:
Os descritores 1X, 2X e 3X indicam quantos espa cos em branco (respectivamente 1, 2 e 3) devem ser deixados na sa da dos dados. Os descritores F e E s ao descritores de edi c ao de dados e eles se aplicam ao dados na lista de vari aveis (A, B e C) na mesma ordem em que aparecem, ou seja, na sa da 1, F7.5 determina a edi c ao da vari avel A, F9.7 determina a adi c ao de B e F11.9 determina a edi c ao de C. O descritor F7.5 indica que a vari avel deve ser impressa no formato de ponto utuante, com um total de 7 algarismos alfanum ericos, contando o ponto decimal e o sinal (se houver), destinando 5 d gitos para a parte fracion aria da vari avel A. Exemplos de n umeros de ponto utuante v alidos s ao:
5 d gitos 7 d gitos 9 d gitos
F7.5: 0.14286
7 caracteres
1 Discutido
F9.7: -.1414214
9 caracteres
F12.9: -3.141592654
12 caracteres
em detalhes na se c ao 9.7 na p agina 134.
Cap tulo 9. Comandos de Entrada/Sa da de Dados
123
O descritor E11.5, que aparece na sa da 2 determinando o formato de sa da da vari avel C, indica a sa da na forma de ponto utuante com parte exponencial. O resultado impresso (0.31416E+01) possui uma extens ao total de 11 algarismos alfanum ericos, contando o ponto decimal, o sinal (se houver), o s mbolo da parte exponencial (E), o sinal da parte exponencial (+) e o seu valor, com duas casas decimais (01). Restam, ent ao, somente 5 d gitos para a parte fracion aria. Caso a extens ao total do descritor, descontado o n umero de d gitos na parte fracion aria, n ao for suciente para imprimir a parte exponencial e mais o sinal, ocorre um estouro de campo, indicado pelos asteriscos nos resultados das vari aveis A e B. Exemplos v alidos de n umeros no formato exponencial s ao:
5 d gitos 6 d gitos
E11.5: 0.31416 E+01

11 caracteres
E13.6: -4. 430949 E-12

13 caracteres
Finalmente, as constantes de caractere A= , B= e C= que aparecem na formata c ao da sa da 3 s ao impressas ipsis literis na sa da padr ao e na mesma ordem em que aparecem, relativamente a si pr oprias e ` as vari aveis.
Uma exposi c ao completa de todos os descritores e realizada na se c ao 9.8 na p agina 135.
Tarefa 2. Entrada formatada a partir do teclado

Entrada formatada a partir do teclado n ao e uma tarefa muito pr atica, pois uma instru c ao do tipo READ(*,FMT=(1X,F7.5,5X,F9.6,3X,F11.8))A, B, C iria requerer a digita c ao dos valores das vari aveis exatamente nas posi c oes assinaladas e com as extens oes e partes fracion arias exatamente como determinadas pelos descritores. Por exemplo, se A= 2.6, B= -3.1 e C= 10.8, seria necess ario digitar 2.60000 -3.100000 10.80000000 para preencher todos os d gitos e espa cos determinados pelos descritores de formata c ao.
Tarefa 3. Sa da de dados em um arquivo

Da mesma maneira que um programa-fonte e gravado em um arquivo situado no disco r gido do computador, e poss vel gravar dados em arquivos a partir de um programa ou, de forma alternativa, ler dados contidos em arquivos situados no disco. Para possibilitar acesso de E/S em um arquivo e necess ario que o programador:
Identique o nome do arquivo, fornecendo o caminho completo, caso o arquivo resida em um diret orio (pasta) distinto do programa execut avel. Informe ao sistema sobre o tipo de acesso e uso que ser a feito do arquivo.
poss Associe instru c oes individuais de leitura ou grava c ao com o arquivo em uso. E vel existir mais de um arquivo simultaneamente acess vel para E/S, al em das interfaces j a utilizadas (teclado e monitor).
Quando as opera c oes de E/S estiverem conclu das, e necess ario instruir ao sistema n ao e mais necess ario acessar o(s) arquivo(s).
O programa exemplo a seguir grava informa c oes formatadas ao arquivo EX1.DAT. A extens ao .DAT simplesmente identica o arquivo como sendo de dados. Se o arquivo n ao existir, este e criado e tornado acess vel; se ele existe, ent ao os dados previamente contidos nele podem ser substitu dos por novos. program Arq Sai i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) r e a l ( dp ) : : a , b , c a= 1 . 0 dp / 7 . 0 dp b= s q r t ( 2 . 0 dp ) c= 4 * atan ( 1 . 0 dp ) open ( 1 0 , f i l e =ex1 . dat ) write ( 1 0 , fmt=( f 7 . 5 , 1 x , f 9 . 7 , 1 x , f 1 1 . 9 ) ) a , b , c close (10) end program Arq Sai
124
9.1. Comandos de Entrada/Sa da: introdu c ao r apida
Alterando os valores das vari aveis A, B e C, altera-se os valores gravados no arquivo EX1.DAT. Os comandos-chave neste exemplo s ao: OPEN(10, FILE="EX1.DAT"). O comando OPEN habilita acesso ao arquivo EX1.DAT para o sistema. O arquivo est a situado no mesmo diret orio que o programa e este ser a criado caso n ao exista previamente, sendo poss vel ent ao a grava c ao no mesmo, ou, caso ele j a exista, ter a acesso de leitura e/ou escrita. O n umero 11 indica a unidade l ogica que ser a acessada. Doravante, o arquivo EX1.DAT ser a sempre identicado pelo programa atrav es deste n umero. O modo como o acesso ao arquivo e feito pode ser alterado de diversas maneiras. A se c ao 9.4 descreve todos os especicadores poss veis do comando OPEN. WRITE(10, FMT="(F7.5,1X,F9.7,1X,F11.9)") A, B, C. Este comando e aqui utilizado no lugar de PRINT para realizar um processo de escrita formatada no arquivo associado ` a unidade l ogica 10. A formata c ao e fornecida pela lista de descritores de formata c ao que seguem a palavra-chave FMT=. O papel destes descritores j a foi esclarecido. O comando essencialmente grava os valores das vari aveis A, B e C de maneira formatada no arquivo associado ` a unidade 10. CLOSE(10). Finalmente, este comando informa ao computador que n ao ser a mais necess ario acessar o arquivo associado ` a unidade l ogica 10 e que tal associa c ao deve ser interrompida.
Tarefa 4. Leitura/escrita de dados em arquivos. Vers ao 1: n umero conhecido de linhas

O programa a seguir l e os dados gravados no arquivo EX1.DAT, criado a partir do programa ARQ_SAI, e usa estes dados para denir valores de outros, os quais ser ao gravados no arquivo EX2.DAT. program A r q S a i 2 i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) r e a l ( dp ) : : a , b , c ! Dados de e n t r a d a . r e a l ( dp ) : : d , e , f ! Dados de s a i d a . open ( 1 0 , f i l e =ex1 . dat , status= o l d ) open ( 1 1 , f i l e =ex2 . dat , status=new ) read ( 1 0 , fmt=( f 7 . 5 , 1 x , f 9 . 7 , 1 x , f 1 1 . 9 ) ) a , b , c print * , Os v a l o r e s l i d o s foram : print * , a= , a print * , b= , b print * , c= , c d= a + b + c e= b ** 2 + c o s ( c ) f= s q r t ( a ** 2 + b ** 3 + c * * 5 ) write ( 1 1 , fmt= ( 3 ( e11 . 5 , 1 x ) ) ) d , e , f end program A r q S a i 2 No programa ARQ_SAI_2 aparecem as seguintes instru c oes que ainda n ao foram discutidas: STATUS="OLD/NEW". Estas cl ausulas, que aparecem nos comandos OPEN, indicam o status exigido para o arquivo a ser acessado. STATUS="OLD" indica que o arquivo deve existir no momento de acesso. Caso isto n ao aconte ca, ocorre uma mensagem de erro e o programa e interrompido. STATUS="NEW" indica que o arquivo n ao deve existir previamente e, ent ao, deve ser criado. Novamente, se estas condi c oes n ao se cumprirem, o programa p ara. READ(10, FMT="(F7.5,1X,F9.7,1X,F11.9)") A, B, C. Observa-se aqui o uso de uma entrada formatada com o comando READ. A formata c ao das vari aveis A, B e C j a foi discutida. Deve-se enfatizar novamente que a formata c ao especicada pelo FMT= deve possibilitar a leitura correta dos dados no arquivo associado ` a unidade l ogica 10. WRITE(11, FMT="(3(E11.5,1X))") D, E, F. O aspecto ainda n ao abordado neste comando WRITE e o uso do contador de repeti c ao 3, o qual indica que as vari aveis D, E e F devem ser gravado no arquivo associado ` a unidade 11 com a formata ca o dada por "E11.5,1X" repetido 3 vezes consecutivas.
125
Finalmente, deve-se mencionar que os comandos CLOSE(10) e CLOSE(11) n ao foram utilizados. Isto e permitido, uma vez que, neste caso, a associa c ao das unidades l ogicas aos arquivos ser a interrompida com o nal da execu c ao do programa. Contudo, em certas situa c oes e necess ario associar uma unidade l ogica previamente empregada a um outro arquivo, o que neste caso obriga o programador a fazer uso do comando CLOSE. Modica c oes posteriores no programa necessitar ao tamb em a elimina c ao do arquivo EX2.DAT, devido ` a cl ausula STATUS="NEW".
Tarefa 5. Leitura/escrita de dados em arquivos. Vers ao 2: n umero desconhecido de linhas

Quando o n umero de linhas no arquivo de entrada n ao e previamente conhecido, e necess ario um procedimento diferente daquele adotado na Tarefa 4. O programa 9.1 ilustra dois poss veis m etodos a ser adotados, os quais utilizam as op c oes IOSTAT ou END do comando READ (se c ao 9.5). Em ambos, aloca-se inicialmente uma matriz tempor aria com o posto adequado e com um n umero tal de elementos que seja sempre maior ou igual ao n umero m aximo de linhas que podem estar contidas no arquivo de entrada. Ap os a leitura dos dados na matriz tempor aria, o n umero de linhas no arquivo tornou-se conhecido e aloca-se, ent ao, uma matriz denitiva com o n umero correto de elementos. O segundo exemplo faz uso de um r otulo (se c ao 5.1.1), que embora n ao seja um procedimento recomendado em Fortran 90/95, e completamente equivalente ao primeiro exemplo. Existem maneiras mais inteligentes de realizar esta tarefa, sem que seja necess ario denir-se uma matriz tempor aria. Por em, estas maneiras envolvem o uso de ponteiros e listas encadeadas (linked lists) os quais constituem recursos mais avan cados e que n ao foram ainda abordados nesta apostila. Os exemplos abordados nas Tarefas 1 5 constituem um conjunto pequeno, por em freq uente, de usos dos comando de E/S. A descri c ao completa destes recursos pode ser obtida nas se c oes 9.39.11 posteriores.
9.2
Declara c ao NAMELIST
Em certas situa c oes, quando h a por exemplo um n umero grande de par ametros sendo transferidos em processos de E/S, pode ser u til denir-se uma lista rotulada de valores destinados ` a transfer encia. O Fortran 90 introduziu, com este m, a declara c ao NAMELIST, que dene um ou mais grupos de vari aveis referenciadas com o mesmo nome. Esta declara c ao e empregada em conjunto com opera c oes de E/S executadas por comandos READ e WRITE. A forma geral da declara c ao, que pode aparecer em qualquer unidade de programa, e: NAMELIST /<nome-grupo-namelist>/ <lista-nomes-vari aveis> & [[,] /<nome-grupo-namelist>/ <lista-nomes-vari aveis> [,] ...] Como se pode notar, e poss vel denir-se mais de um grupo NAMELIST na mesma declara c ao. O primeiro campo substitu vel: <nome-grupo-namelist> , e o nome do grupo para uso subseq uente nos comandos de E/S. A <lista-nomes-vari aveis> , como o nome indica, lista os nomes das vari aveis que comp oe o grupo. N ao podem constar desta lista nomes de matrizes mudas de forma assumida, ou objetos autom aticos, vari aveis de caractere de extens ao vari avel, matrizes aloc aveis, pointers, ou ser um componente de qualquer profundidade de uma estrutura que seja um ponteiro ou que seja inacess vel. Um exemplo v alido de <listanomes-vari aveis> e: REAL :: TV, CARPETE REAL, DIMENSION(10) :: CADEIRAS ... NAMELIST /ITENS_DOMESTICOS/ CARPETE, TV, CADEIRAS Outro exemplo v alido: NAMELIST /LISTA1/ A, B, C /LISTA2/ X, Y, Z poss E vel tamb em continuar a mesma <lista-nomes-vari aveis> de um dado grupo em mais de uma declara c ao contidas no campo de declara co es da unidade de programa. Assim, NAMELIST /LISTA/ A, B, C NAMELIST /LISTA/ D, E, F
126
9.2. Declara c ao NAMELIST
Programa 9.1: Programa que ilustra leitura de arquivo com n umero desconhecido de linhas.
! **************************** PROGRAMA ARQ SAI 3 ****************************** ! Le um a r q u i v o de dados com um numero c o n h e c i d o de e l e m e n t o s por l i n h a , ! mas com um numero d e s c o n h e c i d o de l i n h a s no formato l i v r e , usando ! matrizes temporarias . ! A l e i t u r a do a r q u i v o e r e a l i z a d a de 2 maneiras d i s t i n t a s : ! 1 . Usando a opcao IOSTAT . ! 2 . Usando a opcao END. ! O programa e n t a o imprime na t e l a os dados e o numero de l i n h a s l i d o . ! ! Autor : Rudi G a e l z e r ! Data : Maio /2008 ! program A r q S a i 3 i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) integer : : c o n t r o l e , i , npt1= 0 , npt2= 0 character ( len= 1 ) : : c h a r r e a l ( kind=dp ) , dimension ( : , : ) , a l l o c a t a b l e : : temp1 , temp2 , matriz1 , m a t r i z 2 a l l o c a t e ( temp1 ( 2 , 1 0 0 0 ) , temp2 ( 2 , 1 0 0 0 ) ) ! Aloca m a t r i z e s t e m p o r a r i a s . ! Estima um l i m i t e s u p e r i o r no numero ! de l i n h a s . ! Metodo 1 : usando opcao IOSTAT . open ( 1 0 , f i l e = ex3 . dat , status = old ) do read ( 1 0 , * , i o s t a t= c o n t r o l e ) temp1 ( 1 , npt1 +1) , temp1 ( 2 , npt1 +1) i f ( c o n t r o l e < 0 ) exit ! F i n a l de a r q u i v o d e t e c t a d o . npt1= npt1 + 1 end do close (10) a l l o c a t e ( m a t r i z 1 ( 2 , npt1 ) ) m a t r i z 1= temp1 ( : , : npt1 ) write ( * , fmt= ( Matriz 1 l i d a : , / ) ) print ( 2 ( e10 . 3 , 1 x ) ) , ( m a t r i z 1 ( : , i ) , i= 1 , npt1 ) deallocate ( temp1 ) ! L i b e r a e s p a c o de memoria ocupado por ! temp1 . print ( / , a ) , P r e s s i o n e ENTER/R E T U R N para c o n t i n u a r . read ( * , ( a ) ) c h a r ! Metodo 2 : usando opcao END. open ( 1 0 , f i l e = ex3 . dat , status = old ) do read ( 1 0 , * , end= 1 0 0 ) temp2 ( 1 , npt2 +1) , temp2 ( 2 , npt2 +1) npt2= npt2 + 1 end do 100 continue ! Linha i d e n t i f i c a d a com o r o t u l o 1 0 0 . close (10) a l l o c a t e ( m a t r i z 2 ( 2 , npt2 ) ) m a t r i z 2= temp2 ( : , : npt2 ) print ( Matriz 2 l i d a : , / ) print ( 2 ( e10 . 3 , 1 x ) ) , ( m a t r i z 2 ( : , i ) , i= 1 , npt1 ) deallocate ( temp2 ) ! L i b e r a e s p a c o de memoria ocupado por ! temp2 . print ( / , O numero t o t a l de l i n h a s l i d a s e : , / , & Matriz 1 : , i 4 , 3x , Matriz 2 : , i 4 ) , npt1 , npt2 end program A r q S a i 3
127
e equivalente a uma u nica declara c ao NAMELIST com os 6 nomes de vari aveis listados na mesma ordem acima. Al em disso, um objeto de um grupo NAMELIST pode tamb em pertencer a outros grupos. Se o tipo, par ametro de tipo ou forma de uma vari avel de um grupo e especicado em uma declara c ao na mesma unidade de programa , esta declara c ao deve constar antes da declara c ao NAMELIST, ou ser uma declara c ao de tipo impl cito que regule o tipo e esp ecie das vari aveis que iniciam com aquele caractere explicitado na declara c ao. Um grupo namelist pode possuir o atributo p ublico ou privado, concedido atrav es das declara c oes PUBLIC ou PRIVATE. Contudo, se o grupo possuir o atributo p ublico, nenhum membro seu pode ser declarado com o atributo privado ou possuir componentes privados. Para se executar uma opera c ao de E/S em algum registro (como um arquivo, por exemplo) que contenha um ou mais grupos namelist, o registro sempre ir a iniciar com o caractere &, seguido, sem espa co, pelo <nome-grupo-namelist>, vindo ent ao a lista dos nomes das vari aveis, sendo cada nome seguido por sinais de igual e, ent ao pelo valor da vari avel, podendo ser precedido ou seguido por espa cos em branco. Constantes de caractere devem ser sempre delimitadas em registros de entrada. A lista de nomes e valores de um determinado grupo e sempre encerrada com o caractere / inserido fora de uma constante de caractere. Os comandos READ e WRITE, ao serem empregados em conjunto com um namelist, n ao possuem uma lista expl cita de vari aveis ou constantes a ser transferidas, mas sim o nome do grupo NAMELIST como segundo par ametro posicional ou com o especicador NML= contendo o nome do grupo, no lugar do especicador FMT=. Um exemplo de registro de entrada e: INTEGER :: NO_DE_OVOS, LITROS_DE_LEITE, QUILOS_DE_ARROZ NAMELIST /FOME/ NO_DE_OVOS, LITROS_DE_LEITE, QUILOS_DE_ARROZ READ(5, NML=FOME) O associado exemplo de registro (arquivo) de entrada e: &FOME LITROS_DE_LEITE= 5, NO_DE_OVOS= 12 / Nota-se no registro acima que a ordem de atribui c ao de valores aos nomes n ao e necessariamente a mesma da declara c ao NAMELIST. Al em disso, a vari avel QUILOS_DE_ARROZ n ao tem seu valor atribu do no registro. Quando isso acontece com uma ou mais vari aveis da lista o valor destas permanece inalterado. Os valores de uma matriz podem ser atribu dos atrav es do nome da mesma seguida por = e a lista de constantes que ser ao atribu dos aos elementos da matriz de acordo com o ordenamento padr ao da linguagem, descrito na se c ao 6.6.2. Se a vari avel for de tipo derivado, a lista de valores deve tamb em seguir a ordem poss e o tipo e esp ecie dos componentes constantes da declara c ao do tipo. E vel tamb em denir-se o valor de um elemento isolado ou de uma se c ao de matriz, ou qualquer sub-objeto, sem alterar os valores dos demais elementos, usando um designador de sub-objeto, tal como um tripleto de subscritos. Neste caso, os elementos do tripleto devem todos ser constantes inteiras escalares, sem par ametros de esp ecie de tipo Na grava c ao (sa da) do registro, todos os componentes do grupo s ao escritos no arquivo especicado, precedidos por & e o nome do grupo, na mesma ordem da declara c ao da <lista-nomes-vari aveis> , com os nomes explicitamente escritos em letras mai usculas. O registro e nalizado com o caractere /. Um exemplo de sa da de um namelist e: INTEGER :: NUMERO, I INTEGER, DIMENSION(10) :: LISTA= (/ 14, (0, I= 1,9) /) NAMELIST /SAI/ NUMERO, LISTA WRITE(6, NML=SAI) o qual produz o seguinte registro no arquivo associado ` a unidade l ogica 6: &SAI NUMERO=1 , LISTA=14, 9*0 / Nota-se que os 9 elementos 0 do vetor LISTA s ao registrados usando-se a nota c ao compacta 9*0. Esta nota c ao tamb em e v alida em registros de entrada. Em um processo de leitura de registros (usando o comando READ, por exemplo), n ao e permitida a mistura de registros em um NAMELIST com registros que n ao pertencem a nenhum grupo, como em uma entrada formatada ou n ao-formatada. Contudo, em um processo de sa da de registros (comando WRITE), pode-se misturar os tipos de registros. Todos os nomes de grupos, nomes de objetos e nomes de componentes s ao interpretados sem considerar o caso de capitaliza c ao. A lista de valores n ao pode ter um n umero excedente de tens, mas ela pode conter um n umero inferior, como j a foi mencionado. Se o objeto e do tipo caractere e o valor tiver uma extens ao menor
128
9.2. Declara c ao NAMELIST
que a declarada, espa cos em branco preenchem o restante do campo. Matrizes ou objetos de tamanho zero (se c ao 6.5) n ao podem constar no registro de entrada de um NAMELIST. Se ocorrer uma m ultipla atribui c ao de um mesmo objeto, o u ltimo valor e assumido. Por m, coment arios podem ser inclu dos no registro de entrada em seguida a um nome a uma v rgula que separa os nomes. O coment ario e introduzido, como e costumeiro a partir do caractere !. Uma linha de coment ario, iniciada com o caractere !, tamb em e permitida, desde que esta n ao ocorra em um contexto de uma constante de caractere. O programa Testa_NAMELIST abaixo ilustra praticamente todos os recursos discutidos nesta se c ao a respeito de listas NAMELIST. program Testa NAMELIST i m p l i c i t none integer , parameter : : dp= SELECTED REAL KIND( 1 5 , 3 0 0 ) integer : : n o d e o v o s , l i t r o s d e l e i t e , q u i l o s d e a r r o z= 1 2 , numero ! Note que q u i l o s d e a r r o z f o i i n i c i a l i z a d o . integer , dimension ( 1 0 ) : : l i s t a i n t 1 , l i s t a i n t 2 real , dimension ( 1 0 ) : : a l e a t , v e t t e s= 1 . 0 r e a l ( dp ) : : pi , e e u l e r , m e l e c t r o n , c vacuum logical : : tes character ( len= 1 0 ) : : nome namelist / fome / nome , n o d e o v o s , l i t r o s d e l e i t e , q u i l o s d e a r r o z namelist / s a i / numero , l i s t a i n t 1 , l i s t a i n t 2 , v e t t e s namelist / c t e s / t e s , pi , e e u l e r , m e l e c t r o n , c vacuum ! open ( 1 0 , f i l e = Dados . e n t , status= o l d ) open ( 1 1 , f i l e = Dados . dat ) read ( 1 0 , nml= fome ) read ( 1 0 , nml= s a i ) read ( 1 0 , nml= c t e s ) ! Mostra na t e l a os v a l o r e s l i d o s . print ( a ) , L i s t a / fome / l i d a : write ( * , nml= fome ) print ( / a ) , L i s t a / s a i / l i d a : write ( * , nml= s a i ) print ( / a ) , L i s t a / c t e s / l i d a : write ( * , nml= c t e s ) print ( / a ) , Para c o n f i r m a r : print ( Vetor v e t t e s : , 1 0 ( f 4 . 2 , x ) ) , v e t t e s print ( / , l i s t a 1 : , 1 0 i 3 ) , l i s t a i n t 1 print ( / , l i s t a 2 : , 1 0 i 3 ) , l i s t a i n t 2 ! A l t e r a a l g u n s v a l o r e s e g r a v a as l i s t a s no a r q u i v o . c a l l random number ( a l e a t ) print ( / , L i s t a de No . a l e a t o r i o s : , / , 1 0 ( f 7 . 5 , x ) ) , a l e a t l i s t a i n t 1= l i s t a i n t 2 ** 2 l i s t a i n t 2= a l e a t * l i s t a i n t 2 write ( 1 1 , nml= s a i ) write ( 1 1 , nml= c t e s ) write ( 1 1 , nml= fome ) ! V e r i f i q u e Dados . d a t . end program Testa NAMELIST Um exemplo de arquivo de entrada Dados.ent que pode ser fornecido ao programa Testa_NAMELIST e o seguinte: &fome l i t r o s d e l e i t e= 10 , n o d e o v o s= 2 4 , nome= Rancho / &s a i
Cap tulo 9. Comandos de Entrada/Sa da de Dados numero= 5 0 , l i s t a i n t 1= 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 1 0 , l i s t a i n t 2= 3 * 1 , 3 * 5 , 4 * 8 , v e t t e s (4:8)= 5*2.0 / &c t e s t e s= . t r u e . , PI= 3.14159265358979323846264338327950288419717 , e e u l e r= 2 . 7 1 8 2 8 1 8 2 8 4 5 9 0 4 5 2 3 5 3 6 0 2 8 7 4 7 1 3 5 2 6 6 2 4 9 7 7 5 7 2 5 , ! Euler s number . m e l e c t r o n= 9 . 1 0 9 3 8 2 1 5 e 28 , ! E l e c t r o n r e s t mass ( g ) . c vacuum= 2 . 9 9 7 9 2 4 5 8 e10 ! Speed o f l i g h t i n vacuum (cm/ s ) . /
129
9.3
Unidades l ogicas
Em Fortran, um arquivo est a conectado a uma unidade l ogica denotada por um n umero inteiro. Este n umero deve ser positivo e est a freq uentemente limitado entre 1 e 100, dependendo do compilador. Cada unidade l ogica possui muitas propriedades. Por exemplo, FILE. O nome do arquivo conectado ` a unidade. O nome e especicado pelo comando OPEN. ACTION. Especica o tipo de a c ao que pode ser executada sobre o arquivo. Estas compreendem leitura, escrita ou ambas. Se um arquivo e aberto para um tipo de a c ao e outro tipo e tentado, uma mensagem de erro ser a gerada. Por exemplo, n ao e permitida escrita sobre um arquivo aberto somente para leitura. STATUS. Estabelece o status de um arquivo. Estes s ao: velho (old), novo (new) substitui c ao (replace), entre outros. Caso um arquivo tente ser acessado com um status incorreto, uma mensagem de erro e gerada. ACCESS. Forma de acesso a um arquivo: direto ou seq uencial. Alguns arquivos pode ser acessados por ambos os m etodos, como e o caso de arquivos em discos remov veis ou discos r gidos. J a outras m dias permite acesso somente seq uencial, como e o caso de uma ta magn etica. o acesso usual. Os processos de leitura/escrita principiam no in Sequ cio do arquivo e encial. E seguem, linha a linha, at e o seu nal. Direto. Cada linha e acessada por um n umero, denominado n umero de grava c ao (record number) o qual deve ser especicado no comando de leitura/escrita. O n umero m aximo de arquivos que podem ser abertos simultaneamente para E/S tamb em e especicado pelo manual do compilador.
9.4
Comando OPEN
O comando OPEN e usado para conectar um dado arquivo a uma unidade l ogica. Freq uentemente e poss vel pr e-conectar um arquivo antes que o programa comece a rodar; neste caso, n ao e necess ario usarse o comando OPEN. Contudo, isto depende de conhecimento pr evio a respeito dos n umeros-padr ao das unidades l ogicas para E/S, o que geralmente depende do processador e dos sistema operacional em uso. Para sistemas linux, as unidades pr e-conectadas s ao, usualmente: Uso Mensagens de erro Entrada padr ao Sa da padr ao Designa c ao stderr stdin stdout N umero da unidade l ogica 0 5 6
Sempre que poss vel, e recomendado evitar-se o uso de unidade pr e-conectadas, o que torna o programa mais port avel. A sintaxe do comando e: OPEN([UNIT=] <int-exp> [,<op-list>])
130
9.4. Comando OPEN
onde <int-exp> e uma express ao escalar inteira que especica o n umero da unidade l ogica externa e <oplist> e uma lista de especicadores opcional, formada por um conjunto de palavras-chave. Se a palavrachave UNIT= for inclu da, ela pode aparecer em qualquer posi c ao no campo de argumentos do comando OPEN. Um especicador n ao pode aparecer mais de uma vez. Nos especicadores, todas as entidades s ao escalares e todos os caracteres s ao da esp ecie padr ao. Em express oes de caractere, todos os brancos precedentes s ao ignorados e, exceto no caso do especicador FILE=, quaisquer letras mai usculas s ao convertidas as correspondentes letras min ` usculas. Os especicadores s ao: FILE= <fln>, onde <fln> e uma express ao de caractere que fornece o nome do arquivo. O nome deve coincidir exatamente com o arquivo, inclusive com o caminho, caso o arquivo esteja em um diret orio distinto do diret orio de trabalho. Se este especicador e omitido e a unidade n ao e conectada a uma arquivo, o especicador STATUS= deve ser especicado com o valor SCRATCH e o arquivo conectado ` a unidade ir a depender do sistema. IOSTAT= <ios>, onde <ios> e uma vari avel inteira padr ao que e xada a zero se o comando executou corretamente e a um valor positivo em caso contr ario. ERR= <r otulo-erro>, onde <r otulo-erro> e o r otulo de um comando na mesma unidade de ambito, para o qual o controle do uxo ser a transferido caso ocorra algum erro na execu c ao do comando OPEN. STATUS= <status>, onde <status> e uma express ao de caracteres que fornece o status do arquivo. O status pode ser um dos seguintes: OLD Arquivo deve existir. NEW Arquivo n ao deve existir. O arquivo ser a criado pelo comando OPEN. A partir deste momento, o seu status se torna OLD. REPLACE Se o arquivo n ao existe, ele ser a criado. Se o arquivo j a existe, este ser a eliminado e um novo arquivo e criado com o mesmo nome. Em ambos os casos, o status e ent ao alterado para OLD. SCRATCH O arquivo e tempor ario e ser a deletado quando este for fechado com o comando CLOSE ou na sa da da unidade de programa. UNKNOWN Status do arquivo desconhecido; depende do sistema. Este e o valor padr ao do especicador, caso este seja omitido. O especicador FILE= deve estar presente se NEW ou REPLACE s ao especicados ou se OLD e especicado e a unidade n ao est a conectada. ACCESS= <acc>, onde <acc> e uma express ao de caracteres que fornece o valor SEQUENTIAL ou DIRECT. Para um arquivo que j a exista, este valor deve ser uma op c ao v alida. Se o arquivo ainda n ao existe, ele ser a criado com o m etodo de acesso apropriado. Se o especicador e omitido, o valor SEQUENTIAL e assumido. O signicado das especica c oes e: DIRECT O arquivo consiste em registros acessados por um n umero de identica c ao. Neste caso, o tamanho do registro deve ser especicado por RECL=. Registros individuais podem ser especicados e atualizados sem alterar o restante do arquivo. SEQUENTIAL O arquivo e escrito/lido seq uencialmente, linha a linha. FORM= <fm>, onde <fm> e uma express ao de caracteres que fornece os valores FORMATTED ou UNFORMATTED, determinando se o arquivo deve ser conectado para E/S formatada ou n ao formatada. Para um arquivo que j a exista, o valor deve ser uma op c ao v alida. Se o arquivo ainda n ao existe, ele ser a criado com um conjunto de forma que incluem o forma especicada. Se o especicador e omitido, os valores-padr ao s ao: FORMATTED Para acesso seq uencial. UNFORMATTED Para conex ao de acesso direto. RECL= <rl>, onde <rl> e uma express ao inteira cujo valor deve ser positivo.
Para arquivo de acesso direto, a op c ao especica o tamanho dos registros e e obrigat orio. Para arquivo seq uencial, a op c ao especica o tamanho m aximo de um registro, e e opcional com um valor padr ao que depende do processador.
131
Para arquivos formatados, o tamanho e o n umero de caracteres para registros que contenham somente caracteres-padr ao. Para arquivos n ao formatados, o tamanho depende do sistema, mas o comando INQUIRE (se c ao 9.10) pode ser usado para encontrar o tamanho de uma lista de E/S. Em qualquer situa c ao, para um arquivo que j a exista, o valor especicado deve ser permitido para o arquivo. Se o arquivo ainda n ao existe, ele e criado com um conjunto permitido de tamanhos de registros que incluem o valor especicado. BLANK= <bl>, onde <bl> e uma express ao de caracteres que fornece os valores NULL ou ZERO. A conex ao deve ser com E/S formatada. Este especicador determina o padr ao para a interpreta c ao de brancos em campos de entrada num ericos. NULL Os brancos s ao ignorados, exceto que se o campo for completamente em branco, ele e interpretado como zero. ZERO Os brancos s ao interpretados como zeros. Se o especicados e omitido, o valor padr ao e NULL. POSITION= <pos>, onde <pos> e uma express ao de caracteres que fornece os valores ASIS, REWIND ou APPEND. O m etodo de acesso deve ser seq uencial e se o especicador e omitido, o valor padr ao e ASIS. Um arquivo novo e sempre posicionado no seu in cio. Para um arquivo que j a existe e que j a est a conectado: ASIS O arquivo e aberto sem alterar a posi c ao corrente de leitura/escrita no seu interior. REWIND O arquivo e posicionado no seu ponto inicial. APPEND O arquivo e posicionado logo ap os o registro de nal de arquivo, possibilitando a inclus ao de dados novos. Para um arquivo que j a existe mas que n ao est a conectado, o efeito da especica c ao ASIS no posicionamento do arquivo e indeterminado. ACTION= <act>, onde <act> e uma express ao de caracteres que fornece os valores READ, WRITE ou READWRITE. READ Se esta especica c ao e escolhida, os comandos WRITE, PRINT e ENDFILE n ao devem ser usados para esta conex ao. WRITE Se esta especica c ao e escolhida, o comando READ n ao pode ser usado. READWRITE Se esta especica c ao e escolhida, n ao h a restri c ao. Se o especicador e omitido, o valor padr ao depende do processador. DELIM= <del>, onde <del> e uma express ao de caracteres que fornece os valores APOSTROPHE, QUOTE ou NONE. Se APOSTROPHE ou QUOTE s ao especicados, o caractere correspondente ser a usado para delimitar constantes de caractere escritos com formata c ao de lista ou com o uso da declara c ao NAMELIST, e ser a duplicado onde ele aparecer dentro de tal constante de caractere. Al em disso, caracteres fora do padr ao ser ao precedidos por valores da esp ecie. Nenhum caractere delimitador ser a usado e nenhuma duplica c ao ser a feita se a especica c ao for NONE. A especica c ao NONE e o valor padr ao se este especicador for omitido. O especicador somente pode aparecer em arquivos formatados. PAD= <pad>, onde <pad> e uma express ao de caracteres que fornece os valores YES ou NO. YES Um registro de entrada formatado ser a considerado preenchido por brancos sempre que uma lista de entrada e a formata c ao associada especicarem mais dados que aqueles que s ao lidos no registro. NO Neste caso, o tamanho do registro de entrada deve ser n ao menor que aquele especicado pela lista de entrada e pela formata c ao associada, exceto na presen ca de um especicador ADVANCE= NO e uma das especica c oes EOR= ou IOSTAT=. O valor padr ao se o especicador e omitido e YES. Para caracteres n ao padronizados, o caractere de branco que preenche o espa co restante depende do processador.
132
9.5. Comando READ
A seguir, temos um exemplo do uso deste comando: OPEN(17, FILE= SAIDA.DAT, ERR= 10, STATUS= REPLACE, & ACCESS= SEQUENTIAL, ACTION= WRITE) Neste exemplo, um arquivo SAIDA.DAT e aberto para escrita, e conectado ao n umero de unidade l ogica 17, o arquivo e acessado linha a linha e ele j a existe mas deve ser substitu do. O r otulo 10 deve pertencer a um comando execut avel v alido. OPEN(14, FILE= ENTRADA.DAT, ERR= 10, STATUS= OLD, RECL=IEXP, ACCESS= DIRECT, ACTION= READ) &
Aqui, o arquivo ENTRADA.DAT e aberto somente para leitura na unidade 14. O arquivo e diretamente acessado e deve ser um arquivo previamente existente.
9.5
Comando READ
Este e o comando que executa a leitura formatada de dados. At e agora, o comando foi utilizado para leitura na entrada padr ao, que usualmente e o teclado: READ*, <lista> onde o asterisco * indica a entrada padr ao e <lista> e a lista de vari aveis cujo valor e lido do teclado. Este comando ser a agora generalizado para uma forma com ou sem unidade l ogica. Sem o n umero de unidade l ogica o comando ca: READ <format> [,<lista>] e com o n umero de unidade ca: READ([UNIT=], [FMT=] <format>[, IOSTAT= <ios>] & [, ERR= <err-label>][, END= <end-label>] & [, EOR= <eor-label>][, ADVANCE= <mode>] & [, REC= <int-exp>][, SIZE= <size>][, NML= <grp>]) <lista> Os argumentos do comando s ao os seguintes: UNIT= , onde e um n umero de unidade l ogica v alido ou * para a entrada padr ao. Caso esta especica c ao seja o primeiro argumento do comando, a palavra-chave e opcional. FMT= <format>, onde <format> e uma string de caracteres formatadores, um r otulo v alido em Fortran ou * para formato livre. Caso esta especica c ao seja o segundo argumento do comando, a palavra-chave e opcional. IOSTAT= <ios>, onde <ios> e uma vari avel inteira padr ao que armazena o status do processo de leitura. Os valores poss veis s ao: <ios> = 0, quando o comando e executado sem erros. <ios> > 0, quando ocorre um erro na execu c ao do comando. <ios> < 0, quando uma condi c ao de nal de registro e detectada em entrada sem avan co ou quando uma condi c ao de nal de arquivo e detectada. ERR= <err-label>, e um r otulo v alido para onde o controle de uxo e transferido quando ocorre um erro de leitura. END= <end-label>, e um r otulo v alido para onde o controle de uxo e transferido se uma condi c ao de nal de arquivo e encontrada. Esta op c ao somente existe no comando READ com acesso seq uencial. EOR= <eor-label>, e um r otulo v alido para onde o controle de uxo e transferido se uma condi c ao de nal de registro e encontrada. Esta op c ao somente existe no comando READ com acesso seq uencial e formatado e somente se a especica c ao ADVANCE= NO tamb em estiver presente.
133
ADVANCE= <mode>, onde <mode> possui dois valores: YES ou NO. A op c ao NO especica que cada comando READ inicia um novo registro na mesma posi c ao; isto e, implementa entrada de dados sem avan co (non-advancing I/O ). A op c ao padr ao e YES, isto e a cada leitura o arquivo e avan cado em uma posi c ao. Se a entrada sem avan co e usada, ent ao o arquivo deve estar conectado para acesso seq uencial e o formato deve ser expl cito. REC= <int-exp>, onde <int-exp> e uma express ao inteira escalar cujo valor e o n umero de ndice do registro lido durante acesso direto. Se REC estiver presente, os especicadores END e NML e o formato livre * n ao podem ser tamb em usados. SIZE= <size>, onde <size> e uma vari avel escalar inteira padr ao, a qual guarda o n umero de caracteres lidos. Este especicador somente existe no comando READ e somente se a especica c ao ADVANCE= NO tamb em estiver presente. NML= <grp>, onde <grp> e o nome de um grupo NAMELIST previamente denido em uma declara c ao NAMELIST. O nome <grp> n ao e uma constante de caracteres e sim um nome v alido em Fortran2 . Dado o seguinte exemplo: READ(14, FMT= (3(F10.7,1X)), REC=IEXP) A, B, C este comando especica que o registro identicado pela vari avel inteira IEXP seja lido na unidade 14. O registro deve ser composto por 3 n umeros reais designados pelos descritores F10.7, separados por um espa co em branco. Estes 3 n umeros ser ao atribu dos ` as vari aveis A, B e C. Outro exemplo: READ(*, (A), ADVANCE= NO, EOR= 12, SIZE= NCH) STR especica que a leitura e sem avan co na unidade padr ao; isto e, o cursor na tela do monitor ir a permanecer na mesma linha h a medida que a string STR ser a lida. O comando l e uma constante de caractere porque o descritor no formato e A. Em uma situa c ao normal, isto e, leitura com avan co, o cursor seria posicionado no in cio da pr oxima linha na tela. A vari avel NCH guarda o comprimento da string e o r otulo 12 indica o ponto onde o programa deve se encaminhar se uma condi c ao de nal de registro e encontrada.
9.6
Comandos PRINT e WRITE
Em compara c ao com o comando READ, o comando WRITE suporta os mesmos argumentos, com exce c ao do especicador SIZE. At e agora, foi usada somente forma do comando PRINT para a sa da padr ao de dados, que usualmente e a tela do monitor: PRINT*, <lista> O mesmo comando, generalizado para sa da formatada ca, PRINT <format> [, <lista>] J a a sintaxe mais geral do comando e: WRITE([UNIT=], [FMT=] <format>[, IOSTAT= <ios>] & [, ERR= <err-label>][, ADVANCE= <mode>] & [, REC= <int-exp>][, NML= <grp>]) <lista> Os especicadores deste comando executam, na sua maioria, as mesmas fun c oes executadas pelos especicadores do comando READ, com exce c ao dos seguintes, os quais especicam fun c oes ligeiramente distintas: UNIT= , onde e um n umero de unidade l ogica v alido ou * para a sa da padr ao. Caso esta especica c ao seja o primeiro argumento do comando, a palavra-chave e opcional. IOSTAT= <ios>, onde <ios> e uma vari avel inteira padr ao que armazena o status do processo de escrita. Os valores poss veis s ao: <ios> = 0, quando o comando e executado sem erros.
2 Ver
se c ao 9.2.
134
9.7. Comando FORMAT e especicador FMT= <ios> > 0, quando ocorre um erro na execu c ao do comando. <ios> < 0, quando uma condi c ao de nal de registro e detectada em escrita sem avan co ou quando uma condi c ao de nal de arquivo e detectada.
ERR= <err-label>, e um r otulo v alido para onde o controle de uxo e transferido quando ocorre um erro de escrita. ADVANCE= <mode>, onde <mode> possui dois valores: YES ou NO. A op c ao NO especica que cada comando WRITE inicia um novo registro na mesma posi c ao; isto e, implementa sa da de dados sem avan co (non-advancing I/O ). A op c ao padr ao e YES, isto e a cada escrita, o arquivo e avan cado em uma posi c ao. Se a sa da sem avan co e usada, ent ao o arquivo deve estar conectado para acesso seq uencial e o formato deve ser expl cito. REC= <int-exp>, onde <int-exp> e uma express ao inteira escalar cujo valor e o n umero de ndice do registro a ser escrito durante acesso direto. Se REC estiver presente, os especicadores END e NML e o formato livre * n ao podem ser tamb em usados. NML= <grp>, onde <grp> e o nome de um grupo NAMELIST previamente denido em uma declara c ao NAMELIST. O nome <grp> n ao e uma constante de caracteres e sim um nome v alido em Fortran3 . Considere o seguinte exemplo, WRITE(17, FMT= (I4), IOSTAT= ISTAT, ERR= 10) IVAL aqui, (I4) descreve format de dado inteiro com 4 d gitos, ISTAT e uma vari avel inteira que indica o status do processo de escrita; em caso de erro, o uxo e transferido ao r otulo 10. IVAL e a vari avel cujo valor e escrito na unidade 17. Outro exemplo seria: WRITE(*,(A), ADVANCE= NO) Entrada: Como a especica c ao de escrita sem avan co foi escolhida, o cursor ir a permanecer na mesma linha que a string Entrada: . Em circunst ancias normais, o cursor passaria ao in cio da linha seguinte na tela. Nota-se tamb em o descritor de formato de constante de caracteres expl cito. Como exemplo do uso dos comandos de E/S apresentados nas se c oes 9.4 9.6, o programa a seguir abre um novo arquivo seq uencial chamado notas.dat. O programa ent ao l e o nome de um estudante, seguido por 3 notas, as quais s ao introduzidas pelo teclado (entrada padr ao), escrevendo, nalmente, as notas e a m edia nal em NOTAS.DAT e no monitor (sa da padr ao), na mesma linha do nome. O processo de leitura e escrita e repetido at e que um estudante com o nome Fim e introduzido. P R O G R A M Notas IMPLICIT N O N E C H A R A C T E R(LEN=20) : : name REAL : : mark1 , mark2 , mark3 OPEN (UNIT=4,FILE=NOTAS.DAT ) DO READ( * , * ) name , mark1 , mark2 , mark3 IF ( name == Fim ) EXIT WRITE(UNIT=4,F M T= * ) name , mark1 , mark2 , mark3 , ( mark1 + mark2 + mark3 ) / 3 . 0 WRITE(UNIT= * ,F M T= * ) name , mark1 , mark2 , mark3 , ( mark1 + mark2 + mark3 ) / 3 . 0 END DO CLOSE(UNIT=4) END P R O G R A M Notas
9.7
Comando FORMAT e especicador FMT=
O especicador FMT= em um comando READ ou WRITE pode conter ou o s mbolo de formato livre *, ou uma constante de caracteres que indica o formato ou um r otulo que indica a linha onde se encontra um comando FORMAT. Dado o seguinte exemplo,
3 Ver
se c ao 9.2.
Cap tulo 9. Comandos de Entrada/Sa da de Dados WRITE(17, FMT= (2X,2I4,1X,nome ,A7))I, J, STR
135
este comando escreve no arquivo SAIDA.DAT, aberto em um exemplo anterior, as tr es vari aveis I, J e STR de acordo com o formato especicado: 2 espa cos em branco (2X), 2 objetos inteiros de 4 d gitos em espa cos entre eles (2I4), um espa co em branco (1X) a constante de caractere nome e, nalmente, 7 caracteres de um objeto de caracteres (A7). As vari aveis a ser realmente escritas s ao tomadas da lista de E/S ap os a lista de especica c oes do comando. Outro exemplo: READ(14,*)X, Y Este comando l e dos valores do arquivo ENTRADA.DAT usando formato livre e atribuindo os valores ` as vari aveis X e Y. Finalmente, no exemplo: WRITE(*,FMT= 10)A, B 10 FORMAT(Valores: ,2(F15.6,2X)) O comando WRITE acima usa o formato especicado no r otulo 10 para escrever na sa da padr ao os valores das vari aveis A e B. O formato de sa da pode ser descrito como: 2 inst ancias de: um objeto real com 15 colunas ao todo com uma precis ao de 6 casas decimais (F15.6), seguido por 2 espa cos em branco (2X). O formato de E/S de dados e denido fazendo-se uso dos descritores de edi c ao, abordados na pr oxima se c ao.
9.8
Descritores de edi c ao
Nos exemplos apresentados nas se c oes anteriores, alguns descritores de edi c ao j a foram mencionados. Estes editores fornecem uma especica c ao precisa sobre como os valores devem ser convertidos em uma string escrita em um dispositivo externo (monitor, impressora, etc) ou em um arquivo interno (disco r gido, CD-RW, ta, etc), ou convertido de uma string em um dispositivo de entrada de dados (teclado, etc) ou arquivo interno para as diferentes representa c oes de tipos de vari aveis suportados pela linguagem. Com algumas exce c oes, descritores de edi c ao aparecem em uma lista separados por v rgulas e somente no caso em que a lista de E/S for vazia ou contiver somente matrizes de tamanho zero que os descritores podem estar totalmente ausentes. Em um processador que suporta tanto caracteres mai usculos quanto min usculos, os descritores de edi c ao s ao interpretados de forma independente com rela c ao ao caso. Descritores de edi c ao dividem-se em tr es classes: Descritores de edi c ao de dados: I, B, O, Z, F, E, EN, ES, D, G, L, A. Descritores de controle: T, TL, TR, X, S, SP, SS, BN, BZ, P, :, /. Descritores de edi c ao de strings: H, c, c (onde c e uma constante de caractere). Estes descritores ser ao discutidos em mais detalhes a seguir.
9.8.1
Contadores de repeti c ao
Os descritores de edi c ao de dados podem ser precedidos por um contador de repeti c ao: uma constante inteira positiva (sem sinal), como no exemplo 10F12.3 a qual indica 10 constantes reais com 12 posi c oes ao todo e com precis ao de 3 casas decimais cada. Dos descritores de edi c ao restantes, somente a barra / pode ter um contador de repeti c ao associado. Um contador de repeti c ao tamb em pode ser aplicado a um grupo de descritores de edi c ao, delimitado por par enteses: PRINT (4(I5,F8.2)), (I(J), A(J), J= 1,4) o que e equivalente a escrever: PRINT (I5,F8.2,I5,F8.2,I5,F8.2,I5,F8.2), (I(J), A(J), J= 1,4)
136
9.8. Descritores de edi c ao

Tabela 9.1: Descritores de edi ca o que convertem os tipos intr nsecos.
Descritor A B D E EN ES F G I L O Z
Tipo de dados convertidos Caractere Inteiro de/para base bin aria Real Real com expoente Real com nota c ao de engenharia Real com nota c ao cient ca Real de ponto utuante (sem expoente) Todos os tipo intr nsecos Inteiro L ogico Inteiro de/para base octal Inteiro de/para base hexadecimal
Note tamb em o la co DO implicado (implied-Do list) (I(J), A(J), J= 1,4) o que equivale a escrever I(1), A(1), I(2), A(2), I(3), A(3), I(3), A(3) Contadores de repeti c ao como estes podem ser encadeados: PRINT (2(2I5,2F8.2)), (I(J),I(J+1),A(J),A(J+1), J=1,4,2) Pode-se ver que esta nota c ao possibilita compactar a formata c ao de E/S de dados. Se uma especica c ao de formato e usada com uma lista de E/S que cont em mais elementos que o n umero de descritores de formata c ao, incluindo os contadores de repeti c ao, um novo registro ir a come car e a especica c ao de formato ser a repetida at e que todos os elementos forem cobertos. Isto acontece, por exemplo, no comando abaixo: PRINT (10I8), (I(J), J= 1, 100)
9.8.2
Descritores de edi c ao de dados
Cada tipo intr nseco de vari aveis em Fortran e convertido por um conjunto espec co de descritores, com exce c ao do descritor G, que pode converter qualquer tipo intr nseco. A tabela 9.1 apresenta uma descri c ao das convers oes. Formato dos descritores de edi c ao de dados. Um descritor de edi c ao de dados pode assumir uma das seguintes formas em uma lista de formata c ao de E/S: [<r>]<c><w> [<r>]<c><w>.<m> [<r>]<c><w>.<d> [<r>]<c><w>.<d>[E<e>] onde os campos <r>, <w>, <d> e <e> devem ser todos constantes inteiras positivas (sem sinal). Par ametros de esp ecie de tipo n ao podem ser especicados. O signicado dos campos e o seguinte: <r> e o contador de repeti c ao. O seu valor pode variar entre 1 e 2147483647 (2**31 - 1). Se <r> for omitido, ele e assumido igual a 1. <c> e um dos descritores: I, B, O, Z, F, EN, ES, D, G, L, A. <w> e o n umero total de d gitos no campo (ou a largura do campo ). Se <w> for omitido, e assumido um valor padr ao que pode variar com o sistema, por em <w> n ao pode ser nulo.
137
<m> e o n umero m nimo de d gitos que devem aparecer no campo (incluindo zeros precedentes). O intervalo permitido para <m> inicia em 0 mas o valor nal depende do sistema. <d> e o n umero de d gitos ` a direita do ponto decimal (os d gitos signicativos ). O intervalo de <d> inicia em 0 mas o valor nal depende do sistema. O n umero de d gitos signicativos e afetado se um fator de escala e especicado para o descritor de edi c ao. E identica um campo de expoente. <e> e o n umero de d gitos no expoente. O intervalo de <e> inicia em 1 mas o valor nal depende do sistema. Os descritores de edi c ao de dados t em as seguintes formas espec cas: Tipo de dado Inteiro Real e Complexo L ogico Caractere Descritores de dado I<w>[.<m>], B<w>[.<m>], O<w>[.<m>], Z<w>[.<m>], G<w>.<d>[E<e>] F<w>.<d>, E<w>.<d>[E<e>], EN<w>.<d>[E<e>], ES<w>.<d>[E<e>], D<w>.<d>, G<w>.<d>[E<e>] L<w>, G<w>.<d>[E<e>] A[<w>], G<w>.<d>[E<e>]
O campo <d> deve ser especicado com os descritores F, E, D e G mesmo se <d> for zero. O ponto decimal tamb em e exigido. Para uma constante de caractere, o campo <w> e opcional, independente do tamanho da constante. Para todos os descritores num ericos, se o campo de escrita for muito estreito para conter o n umero completo, de acordo com a descri c ao fornecida, o campo e preenchido por <w> asteriscos. Na sa da os n umeros s ao geralmente escritos deslocados para a direita no espa co de campo especicado por <w>; isto e feito preenchendo de espa cos em branco ` a esquerda, caso necess ario. Valores negativos s ao sempre escritos com o sinal de menos. Na entrada os n umeros tamb em deveriam ser lidos a partir da direita. Espa cos em branco ` a esquerda s ao ignorados. Se o campo e todo composto por espa cos em branco, o registro ser a lido como zero. N umeros inteiros (I<w>[.<m>], B<w>[.<m>], O<w>[.<m>], Z<w>[.<m>]) Na sua forma b asica, I<w>, o inteiro ser a lido ou escrito no campo de largura <w> ajustado ` a direita. Representando um espa co em branco por , o valor -99 escrito sob o controle de I5 ir a ser aparecer como -99, com o sinal contando como uma posi c ao no campo. Para impress ao, uma forma alternativa deste descritor permite que o n umero de d gitos a ser impressos sejam especicados exatamente, mesmo que alguns deles tenham que ser zeros. Trata-se da forma I<w>.<m>, onde <m> indica o n umero m nimo de d gitos a ser impressos. Neste caso, o valor 99 impresso sob o controle de I5.3 aparecer a como 099. O valor <m> pode ser zero, em cuja situa c ao o campo ser a preenchido por brancos se o n umero impresso for 0. Na entrada, I<w>.<m> e interpretado exatamente da mesma forma que I<w>. Inteiros tamb em podem ser convertidos pelos descritores B<w>[.<m>], O<w>[.<m>] e Z<w>[.<m>]. Estes s ao similares ao descritor I, por em destinados a representar o n umero inteiro nos sistemas num ericos bin ario, octal e hexadecimal, respectivamente. N umeros reais (F<w>.<d>, E<w>.<d>[E<e>], EN<w>.<d>[E<e>], ES<w>.<d>[E<e>], D<w>.<d>) A forma b asica, F<w>.<d>, gera um n umero real de ponto utuante. O ponto decimal conta como uma posi c ao no campo. Na entrada de dados, se a string possui um ponto decimal, o valor de <d> e ignorado. Por exemplo, a leitura da string 9.3729 com o descritor F8.3 causa a transfer encia do valor 9.3729. Todos os d gitos s ao usados, mas arredondamento pode ocorrer devido ` a representa c ao nita de um n umero pelo computador. H a outras duas formas de entrada de n umeros aceit aveis pelo descritor F<w>.<d>: 1. N umero sem ponto decimal. Neste caso, os <d> d gitos mais ` a direita ser ao tomados como a parte fracion ario do n umero. Por exemplo, a string -14629ser a lida pelo descritor F7.2 como -146.29. 2. N umero real na forma padr ao; a qual envolve uma parte exponencial (se c ao 3.3), como o n umero -14.629E-2 ou sua forma variante, onde o expoente sempre tem sinal e o indicador de expoente E e omitido: -14.629-2. Neste caso, o campo <d> ser a novamente ignorado e o n umero na forma exponencial ser a escrita na forma de ponto utuante. Sob o controle do descritor F9.1, a string anterior ser a convertida ao n umero 0.14629.
138
Estas propriedades aplicam-se ` a entrada de dados. Na sa da de dados, os valores s ao arredondados seguindo as regras normais de aritm etica. Assim, o valor 10.9336, sob o controle do descritor F8.3 ir a aparecer escrito como 10.934 e sob o controle de F4.0 ir a aparecer como 11. (note o ponto). O descritor de edi c ao E possui duas formas, E<w>.<d> e E<w>.<d>E<e> e e uma maneira mais apropriada de transferir n umeros abaixo de 0.01 ou acima de 1000. As regras para estes descritores na entrada de dados s ao id enticas ` as do descritor F<w>.<d>. Na sa da com o descritor E<w>.<d>, uma string de caractere contendo a parte inteira com valor absoluto menor que um e quatro caracteres que consistem ou no E seguido por um sinal e dois d gitos ou de um sinal seguido por tr es d gitos. Assim, o n umero 1.234 1023 , convertido pelo descritor E10.4 vai gerar a string .1234E + 24 ou .1234 + 024. A forma contendo a letra E n ao e usada se a magnitude do expoente exceder 99. Por exemplo, E10.4 ir a imprimir o n umero 1.234 10150 como .1234 149. Alguns processadores p oe um zero antes do ponto decimal. Note que agora o valor de <w> deve ser grande o suciente para acomodar, al em dos d gitos, o sinal (se for negativo), o ponto decimal, a letra E (caso poss vel), o sinal do expoente e o expoente. Assim, caso se tentasse imprimir o n umero anterior com o descritor F9.4, apareceria *********. Na segunda forma do descritor, E<w>.<d>E<e>, o campo <e> determina o n umero de d gitos no expoente. Esta forma e obrigat oria para n umeros cujos expoentes t em valor absoluto maior que 999. Assim, o n umero 1.234 101234 , com o descritor E12.4E4 e transferido como a string .1234E + 1235. O descritor de edi c ao EN implementa a nota c ao de engenharia. Ele atua de forma semelhante ao descritor E, exceto que na sa da o expoente decimal e m ultiplo de 3, a parte inteira e maior ou igual a 1 e menor que 1000 e o fator de escala n ao tem efeito. Assim, o n umero 0.0217 transferido sob EN9.2 ser a convertido a 21.70E-03 ou 21.70-003. O descritor de edi c ao ES implementa a nota c ao cient ca. Ele atua de forma semelhante ao descritor E, exceto que na sa da o valor absoluto da parte inteira e maior ou igual a 1 e menor que 10 e o fator de escala n ao tem efeito. Assim, o n umero 0.0217 transferido sob ES9.2 ser a convertido a 2.17E-02 ou 2.17E-002. N umeros complexos (F<w>.<d>, E<w>.<d>[E<e>], EN<w>.<d>[E<e>], ES<w>.<d>[E<e>], D<w>.<d>) N umeros complexos podem ser editados sob o controle de pares dos mesmos descritores de n umeros reais. Os dois descritores n ao necessitam ser id enticos. O valor complexo (0.1,100.), convertido sob o controle de F6.1,8.1 seria convertido a 0.1 .1E+03. Os dois descritores podem ser separados por uma constante de caracteres e descritores de controle de edi c ao. Valores l ogicos (L<w>) Valores l ogicos podem ser editados usando o descritor L<w>. este dene um campo de tamanho <w> o qual, na entrada consiste de brancos opcionais, opcionalmente seguidos por um ponto decimal, seguido por T ou F. Opcionalmente, este caractere pode ser seguido por caracteres adicionais. Assim, o descritor L7 permite que as strings .TRUE. e .FALSE. sejam lidas com o seu signicado correto. Na sa da, um dos caracteres T ou F ir a aparecer na posi c ao mais ` a direita do campo. Vari aveis de caracteres A[<w>] Valores de caracteres podem ser editados usando o descritor A com ou sem o campo <w>. Sem o campo, a largura do campo de entrada ou sa da e determinado pelo tamanho real do tem na lista de E/S, medido em termos do n umero de caracteres de qualquer esp ecie. Por outro lado, usando-se o campo <w> pode-se determinar o tamanho desejado da string lida ou escrita. Por exemplo, dada a palavra TEMPORARIO, temos os seguintes resultados no processo de escrita: Descritor A A11 A8 Registro escrito TEMPORARIO TEMPORARIO TEMPORAR
Ou seja, quando o campo do descritor e menor que o tamanho real do registro, este e escrito com os caracteres mais ` a esquerda. Por outro lado, em caso de leitura da mesma string, as seguintes formas ser ao geradas: Descritor A A11 A8
Registro lido TEMPORARIO TEMPORARIO TEMPORAR

139
Todos os caracteres transferidos sob o controle de um descritor A ou A<w> t em a esp ecie do tem na lista de E/S. Al em disso, este descritor eou nico que pode ser usado para transmitir outros tipos de caracteres, distintos dos caracteres padr oes. Descritor geral G<w>.<d>[E<e>] O descritor de edi c ao geral pode ser usado para qualquer tipo intr nseco de dados. Quando usado para os tipos real ou complexo, a sua a c ao e id entica ` a do descritor E<w>.<d>[E<e>], exceto que na sa da de dados, quando a magnitude (n) do valor est a no intervalo 0.1 0.5 10<d>1 n < 10<d> 0.5 ou zero quando <d>= 0, s ao convertidas como com o descritor F, seguidos pelo mesmo n umero de brancos que o descritor E teria reservado ` a parte exponencial. Esta forma eu til para escrever valores cujas magnitudes n ao s ao bem conhecidas previamente e quando a convers ao do descritor F e prefer vel ` a do descritor E. Quando o descritor G e usado para os tipos inteiro, l ogico e de caracteres, ele segue as regras dos respectivos descritores de edi c ao . Tipos derivados Valores de tipos derivados s ao editados pela seq u encia apropriada de descritores de edi c ao correspondentes aos tipos intr nsecos dos componentes do tipo derivado. Como exemplo, TYPE :: STRING INTEGER :: COMP CHARACTER(LEN= 20) :: PALAVRA END TYPE STRING TYPE(STRING) :: TEXTO READ(*, (I2,A))TEXTO Edi c ao de tamanho m nimo de campo Para possibilitar que os registros de sa da contenham o m nimo poss vel de espa co n ao usado, os descritores I, F, B, O e Z podem especicar um tamanho de campo igual a zero, como em I0 ou F0.3. Isto n ao denota um campo de tamanho nulo, mas um campo com o tamanho m nimo necess ario para conter o valor de sa da em quest ao. Este recurso existe para que o programador n ao precise se preocupar se o tamanho de um campo e suciente para conter o dado, em cuja situa c ao o uso padr ao destes descritores iria gerar uma sa da composta somente por asteriscos. Descritor de edi c ao de string de caracteres Uma constante de caracteres da esp ecie padr ao, sem um par ametro de esp ecie especicado, pode ser transferida a um arquivo de sa da inserindo-a na especica c ao de formato, como no exemplo: PRINT(Este e um exemplo!) O qual vai gerar o registro de sa da: Este e um exemplo cada vez que o comando seja executado. Descritores de edi c ao de string de caracteres n ao podem ser usados em entrada de dados.
9.8.3
Descritores de controle de edi c ao
Um descritor de controle de edi c ao age de duas formas: determinando como texto e organizado ou afetando as convers oes realizadas por descritores de edi c ao de dados subseq uentes.
140
Formato dos descritores de controle de edi c ao Um descritor de controle de edi c ao pode assumir uma das seguintes formas em uma lista de formata c ao de E/S: <c> <c><n> <n><c> onde: <c> e um dos seguintes c odigos de formato: T, TL, TR, X, S, SP, SS, BN, BZ, P, dois pontos (:) e a barra (/). <n> e um n umero de posi c oes de caracteres. Este n umero n ao pode ser uma vari avel; deve ser uma constante inteira positiva sem especica c ao de par ametro de esp ecie de tipo. O intervalo de <n> inicia em 1 at e um valor que depende do sistema. Em processadores Intel de 32 bits, por exemplo, o maior valor e <n>= 2**15 - 1. Em geral, descritores de controle de edi c ao n ao s ao repet veis. A u nica exce c ao e a barra (/), a qual pode tamb em ser precedida por um contador de repeti c ao. Os descritores de controle possuem a seguintes formas espec cas quanto ` as suas fun c oes: Tipo de controle Posicional Sinal Interpreta c ao de brancos Fator de escala Miscel aneo Descritores de controle T<n>, TL<n>, TR<n>, <n>X S, SP, SS BN, BZ <k>P :, /
O descritor P e uma exce c ao ` a sintaxe geral dos descritores. Ele e precedido por um fator de escala (<k>), em vez de um especicador de posi c ao. Descritores de controle de edi c ao tamb em podem ser agrupados em par enteses e precedidos por um contador de repeti c ao do grupo. Edi c ao posicional Os descritores T, TL, TR e X especicam a posi c ao onde o pr oximo caractere e transferido de ou para um registro. Na sa da, estes descritores n ao executam a convers ao e transfer encia de caracteres propriamente dita, al em de n ao afetarem o tamanho do registro. Se caracteres s ao transferidos a posi c oes na posi c ao especicada por um destes descritores, ou ap os esta, posi c oes saltadas e que n ao eram previamente preenchidas por brancos passam a ser preenchidas. O resultado e como se o registro por completo estava inicialmente preenchido por brancos. Edi c ao T O descritor T especica uma posi c ao de caractere em um registro de E/S. Ele toma a seguinte forma: T<n> onde <n> e uma constante positiva que indica a posi c ao de caractere do registro, relativa ao limite ` a esquerda do tabulador. Na entrada, o descritor posiciona o registro externo a ser lido na posi c ao de caractere especicada por <n>. Na sa da, o descritor indica que a transfer encia de dados inicia na <n>- esima posi c ao de caractere do registro externo. Exemplos. Suponha que um arquivo possua um registro contendo o valor ABC de leitura seja executado: CHARACTER(LEN= 3) :: VALOR1, VALOR2 ... READ(11,(T7,A3,T1,A3))VALOR1, VALOR2
XYZe o seguinte comando
Cap tulo 9. Comandos de Entrada/Sa da de Dados Os valores lidos ser ao VALOR1= XYZ e VALOR2= ABC. Suponha agora que o seguinte comando seja executado: PRINT 25 25 FORMAT(T51,COLUNA 2,T21,COLUNA 1) a seguinte linha e impressa na tela do monitor (ou na sa da padr ao):
141
00000000011111111112222222222333333333344444444445555555555666666666677777777778 12345678901234567890123456789012345678901234567890123456789012345678901234567890 | | COLUNA 1 COLUNA 2 Deve-se notar que as constantes de caractere foram impressas iniciando nas colunas 20 e 50 e n ao nas colunas 21 e 51. Isto ocorreu porque o primeiro caractere do registro impresso foi reservado como um caractere de controle. Este e o comportamento padr ao na sa da de dados. Edi c ao TL O descritor TL especica uma posi c ao de caractere ` a esquerda da posi c ao corrente no registro de E/S. O descritor toma a seguinte forma: TL<n> onde <n> e uma constante inteira positiva indicando a <n>- esima posi c ao ` a esquerda do caractere corrente. Se <n> e maior ou igual ` a posi c ao corrente, o pr oximo caractere acessado e o primeiro caractere do registro. Exemplo. No exemplo anterior, temos: PRINT 25 25 FORMAT(T51,COLUNA 2,T21,COLUNA 1,TL20,COLUNA 3) o que gera na tela:
00000000011111111112222222222333333333344444444445555555555666666666677777777778 12345678901234567890123456789012345678901234567890123456789012345678901234567890 | | | COLUNA 3 COLUNA 1 COLUNA 2 Edi c ao TR O descritor TR especica uma posi c ao de caractere ` a direita da posi c ao corrente no registro de E/S. O descritor toma a seguinte forma: TR<n> onde <n> e uma constante inteira positiva indicando a <n>- esima posi c ao ` a direita do caractere corrente. Edi c ao X O descritor X especica uma posi c ao de caractere ` a direita da posi c ao corrente no registro de E/S. Este descritor e equivalente ao descritor TR. O descritor X toma a seguinte forma: <n>X onde <n> e uma constante inteira positiva indicando a <n>- esima posi c ao a ` direita do caractere corrente. Na sa da, este descritor n ao gera a grava c ao de nenhum caractere quando ele se encontra no nal de uma especica c ao de formato.
142 Edi c ao de sinal
Os descritores S, SP e SS controlam a sa da do sinal de mais (+) opcional dentro de campos de sa da num ericos. Estes descritores n ao t em efeito durante a execu c ao de comandos de entrada de dados. Dentro de uma especica c ao de formato, um descritor de edi c ao de sinal afeta todos os descritores de dados subseq uentes I, F, E, EN, ES, D e G at e que outro descritor de edi c ao de sinal seja inclu do na formata c ao. Edi c ao SP O descritor SP for ca o processador a produzir um sinal de mais em qualquer posi c ao subseq uente onde ele seria opcional. O descritor toma a forma simples SP Edi c ao SS O descritor SS for ca o processador a suprimir um sinal de mais em qualquer posi c ao subseq uente onde ele seria opcional. O descritor toma a forma simples SS Edi c ao S O descritor S retorna o status do sinal de mais como opcional para todos os campos num ericos subseq uentes. O descritor toma a forma simples S Interpreta c ao de brancos Os descritores BN e BZ controlam a interpreta c ao de brancos posteriores embebidos dentro de campos de entrada num ericos. Estes descritores n ao t em efeito durante a execu c ao de comandos de sa da de dados. Dentro de uma especica c ao de formato, um descritor de edi c ao de brancos afeta todos os descritores de dados subseq uentes I, B, O, Z, F, E, EN, ES, D e G at e que outro descritor de edi c ao de brancos seja inclu do na formata c ao. Os descritores de edi c ao de brancos sobrep oe-se ao efeito do especicador BLANK durante a execu c ao de um comando de entrada de dados. Edi c ao BN O descritor BN for ca o processador a ignorar todos os brancos posteriores embebidos em campos de entrada num ericos. O descritor toma a forma simples: BN O campo de entrada e tratado como se todos os brancos tivessem sido removidos e o restante do campo e escrito na posi c ao mais ` a direita. Um campo todo composto de brancos e tratado como zero. Edi c ao BZ O descritor BZ for ca o processador a interpretar todos os brancos posteriores embebidos em campos de entrada num ericos como zeros. O descritor toma a forma simples: BN Edi c ao de fator de escala P O descritor P especica um fator de escala, o qual move a posi c ao do ponto decimal em valores reais e das duas partes de valores complexos. O descritor toma a forma <k>P
143
onde <k> e uma constante inteira com sinal (o sinal e opcional, se positiva) especicando o n umero de posi c oes, para a esquerda ou para a direita, que o ponto decimal deve se mover (o fator de escala). O intervalo de valores de <k> e de -128 a 127. No in cio de um comando de E/S formatado, o valor do fator de escala e zero. Se um descritor de escala e especicado, o fator de escala e xado, o qual afeta todos os descritores de edi c ao de dados reais subseq uentes at e que outro descritor de escala ocorra. Para redenir a escala a zero, deve-se obrigatoriamente especicar 0P. Na entrada, um fator de escala positivo move o ponto decimal para a esquerda e um fator negativo move o ponto decimal para direita. Quando um campo de entrada, usando os descritores F, E, D, EN, ES ou G, cont em um expoente expl cito, o fator de escala n ao tem efeito. Nos outros casos, o valor interno do dado lido na lista de E/S e igual ao campo externo multiplicado por 10<k> . Por exemplo, um fator de escala 2P multiplica um valor de entrada por 0.01, movendo o ponto decimal duas posi c oes ` a esquerda. Um fator de escala -2P multiplica o valor de entrada por 100, movendo o ponto decimal duas posi c oes ` a direita. A seguinte tabela apresenta alguns exemplos do uso do especicador <k>P na entrada de dados: Formato 3PE10.5 3PE10.5 -3PE10.5 Campo de entrada 37.614 37.614E2 37.614 Valor interno .037614 3761.4 37614.0
O fator de escala deve preceder o primeiro descritor de edi c ao real associado com ele, mas n ao necessariamente deve preceder o descritor propriamente dito. Por exemplo, todos os seguintes formatos t em o mesmo efeito: (3P,I6,F6.3,E8.1) (I6,3P,F6.3,E8.1) (I6,3PF6.3,E8.1) Note que se o fator de escala precede imediatamente o descritor real associado, a v rgula e opcional. Na sa da, um fator de escala positivo move o ponto decimal para a direita e um fator de escala negativo move o ponto decimal para a esquerda. Neste caso, o efeito do fator de escala depende em que tipo de edi c ao real est a associada com o mesmo, como segue:
Para edi c ao F, o valor externo iguala o valor interno da lista de E/S multiplicado por 10<k> , alterando a magnitude do dado. Para edi c oes E e D, o campo decimal externo da lista de E/S e multiplicado por 10<k> e <k> e subtra do do expoente, alterando a magnitude do dado. Um fator de escala positivo diminui o expoente; um fator de escala negativo aumenta o expoente. Para fator de escala positivo, <k> deve ser menor que <d>+2 sen ao ocorrer a um erro no processo de convers ao de sa da. Para edi c ao G, o fator de escala n ao tem efeito se a magnitude do dado a ser impresso est a dentro do intervalo efetivo do descritor. Se a magnitude estiver fora do intervalo efetivo do descritor, edi c ao E e usada e o fator de escala tem o mesmo efeito como neste caso. Para edi c oes EN e ES, o fator de escala n ao tem efeito.
A seguir, alguns exemplos de sa da de dados usando o descritor P: Formato 1PE12.3 1PE12.2 -1PE12.2 Campo de entrada -270.139 -270.139 -270.139 Valor interno -2.701E+02 -2.70E+02 -0.03E+04
O exemplo a seguir tamb em usa edi c ao P: REAL, DIMENSION(6) :: A= 25.0 WRITE(6,10) A 10 FORMAT( , F8.2,2PF8.2,F8.2) resultando os seguintes valores gravados na unidade 6: 25.00 2500.00 2500.00 2500.00 2500.00 2500.00
144 Edi c ao com barra (/)
O descritor / termina a transfer encia de dados para o registro corrente e inicia a transfer encia de dados para um registro novo. Em um arquivo ou na tela, o descritor tem a a c ao de iniciar uma nova linha. A forma que o descritor toma e: [<r>]/ onde <r> e um contador de repeti c ao. O intervalo de <r> inicia em 1 at e um valor que depende do sistema. Em processadores intel de 32 bits, o valor m aximo e <r>= 2**15-1. M ultiplas barras for cam o sistema a pular registros de entrada ou a gerar registros brancos na sa da, como segue:
Quando n barras consecutivas aparecem entre dois descritores de edi c ao, n - 1 registros s ao pulados na entrada ou n - 1 registros brancos s ao gerados na sa da. A primeira barra termina o registro corrente. A segunda barra termina o primeiro pulo ou registro em branco e assim por diante. Quando n barras consecutivas aparecem no in cio ou nal de uma especica c ao de formato, n registros s ao pulados ou n registros em branco s ao gerados na sa da, porque o par enteses inicial e nal da especica c ao de formato s ao, por si mesmos, iniciadores ou nalizadores de registros, respectivamente
Por exemplo, dado a seguinte formata c ao de sa da: WRITE(6,99) 99 FORMAT(1,T51,Linha Cabe calho//T51,Sublinha Cabe calho//) ir a gerar os seguintes registros no arquivo: 00000000011111111112222222222333333333344444444445555555555666666666677777777778 12345678901234567890123456789012345678901234567890123456789012345678901234567890 | Linha Cabe calho <linha em branco> Sublinha Cabe calho <linha em branco> <linha em branco> Edi c ao com dois pontos (:) O descritor : termina o controle de formato se n ao houver mais tens na lista de E/S. Por exemplo, supondo os seguintes comandos: PRINT 1, 3 PRINT 2, 13 1 FORMAT( I=,I2, J=,I2) 2 FORMAT( K=,I2,:, L=,I2) as seguintes linhas aparecem na sa da: I= 3 J= K=13 Se houver tens de E/S restantes, o descritor : n ao tem efeito.
9.8.4
Descritores de edi c ao de strings
Descritores de edi c ao de strings controlam a sa da das constantes de string. Estes descritores s ao:
Constantes de caracteres Descritor de edi c ao H (eliminado no Fortran 95).
Um descritor de edi c ao de strings n ao pode ser precedido por um contador de repeti c ao; contudo, eles podem fazer parte de um grupo contido entre par enteses, o qual, por sua vez, e precedido por um contador de repeti c ao.
Cap tulo 9. Comandos de Entrada/Sa da de Dados Edi c ao de constantes de caracteres
145
O descritor de constante de caracteres provoca a sa da de uma constante de string em um registro externo. Ele vem em duas formas:
<string> <string>
onde <string> e uma constante de caracteres, sem especica c ao de esp ecie. O seu comprimento e o n umero de caracteres entre os delimitadores; dois delimitadores consecutivos s ao contados como um caractere. Para incluir um ap ostrofe () em uma constante de caractere que e delimitada por ap ostrofes, deve-se colocar duas ap ostrofes consecutivas () na formata c ao. Por exemplo, 50 FORMAT(Todays date is: ,i2,/,i2,/,i2)
Da mesma forma, para incluir aspas () em uma constante de caractere que e delimitada por aspas, deve-se colocar duas aspas consecutivas na formata c ao. Como exemplo do uso dos comandos de E/S apresentados nas se c oes 9.4 9.8, o programa a seguir abre o arquivo pessoal.dat, o qual cont em registros dos nomes de pessoas (at e 15 caracteres), idade (inteiro de 3 d gitos), altura (em metros e cent metros) e n umero de telefone (inteiro de 8 d gitos). O programa l e estes dados contidos em pessoal.dat e os imprime no monitor no formato: Altura Nome Idade (metros) Tel. No. -------------------P. A. Silva 45 1,80 33233454 J. C. Pedra 47 1,75 34931458 etc. P R O G R A M Pessoais dados IMPLICIT N O N E C H A R A C T E R(LEN=15) : : name INTEGER : : age , t e l n o , stat REAL : : h e i g h t OPEN(UNIT=8, FILE= p e s s o a l . dat ) WRITE( * , 1 0 0 ) 100 F O R M A T( T24 , Altura ) WRITE( * , 2 0 0 ) 200 F O R M A T(T4 , Nome , T17 , Idade , T23 , ( metros ) , T32 , Tel . No . ) WRITE( * , 3 0 0 ) 300 F O R M A T(T4, ,T17, ,T23 , , T32,) DO READ( 8 , F M T= ( a15 , 1 x , i 3 , 1 x , f 4 . 2 , 1 x , i 8 ) , IOSTAT = stat ) name , & age , h e i g h t , t e l n o IF ( stat < 0) EXIT ! Testa f i n a l de a r q u i v o WRITE( * , 4 0 0 ) name , age , h e i g h t , t e l n o 400 F O R M A T(A, T18 , I3 , T25 , F4 . 2 , T32 , I 8 ) END DO END P R O G R A M Pessoais dados sendo que o arquivo pessoal.dat possui a seguinte formata c ao: P . A. S i l v a J . C . Pedra 045 1 . 8 0 33233454 047 1 . 7 5 34931458
Cabe ressaltar tamb em que os comandos FORMAT utilizados nos r otulos 100, 200, 300 e 400 poderiam ser igualmente substitu dos pelo especicador FMT=. Por exemplo, as linhas WRITE(*,200) 200 FORMAT(T4,Nome,T17,Idade,T23,(metros),T32,Tel. No.) s ao equivalentes a WRITE(*, FMT=(T4,Nome,T17,Idade,T23,(metros),T32,Tel.
No.))
146
9.9. Comando CLOSE
9.9
Comando CLOSE
CLOSE([UNIT=][, IOSTAT=<ios>][, ERR= <err-label>][, STATUS=<status>])
O prop osito do comando CLOSE e desconectar um arquivo de uma unidade. Sua forma e:
onde , <ios> e <err-label> t em os mesmos signicados descritos para o comando OPEN (se c ao 9.4). Novamente, especicadores em palavras-chaves podem aparecer em qualquer ordem, mas o especicador de unidade deve ser o primeiro ser for usada a forma posicional. A fun c ao do especicador STATUS= e de determinar o que acontecer a com o arquivo uma vez desconectado. O valor de <status>, a qual e uma express ao escalar de caracteres da esp ecie padr ao, pode ser um dos valores KEEP ou DELETE, ignorando qualquer branco posterior. Se o valor e KEEP, um arquivo que existe continuar a existindo ap os a execu c ao do comando CLOSE, e pode ser posteriormente conectado novamente a uma unidade. Se o valor e DELETE, o arquivo n ao mais existir a ap os a execu c ao do comando. Se o especicador for omitido, o valor padr ao e KEEP, exceto se o arquivo tem o status SCRATCH, em cujo caso o valor padr ao e DELETE. Em qualquer caso, a unidade ca livre para ser conectada novamente a um arquivo. O comando CLOSE pode aparecer em qualquer ponto no programa e se e executado para uma unidade n ao existente ou desconectada, nada acontece. No nal da execu c ao de um programa, todas as unidades conectadas s ao fechadas, como se um comando CLOSE sem o especicador STATUS= fosse aplicado a cada unidade conectada. Como exemplo: CLOSE(2, IOSTAT=IOS, ERR=99, STATUS=DELETE)
9.10
Comando INQUIRE
O status de um arquivo pode ser denido pelo sistema operacional antes da execu c ao do programa ou pelo programa durante a sua execu c ao, seja por um comando OPEN ou seja por alguma a c ao sobre um arquivo pr e-conectado que o faz existir. Em qualquer momento, durante a execu c ao do programa, e poss vel inquirir a respeito do status e atributos de um arquivo usando o comando INQUIRE. Usando uma variante deste comando, e poss vel determinar-se o status de uma unidade; por exemplo, se o n umero de unidade existe para o sistema em quest ao, se o n umero est a conectado a um arquivo e, em caso armativo, quais os atributos do arquivo. Outra variante do comando permite inquirir-se a respeito do tamanho de uma lista de sa da quando usada para escrever um registro n ao formatado. Alguns atributos que podem ser determinados pelo uso do comando INQUIRE s ao dependentes de outros. Por exemplo, se um arquivo n ao est a conectado a uma unidade, n ao faz sentido inquirir-se a respeito da forma de acesso que est a sendo usada para este arquivo. Se esta inquiri c ao e feita, de qualquer forma, o especicador relevante ca indenido. As tr es variantes do comando s ao conhecidas como INQUIRE por arquivo, INQUIRE por unidade e INQUIRE por lista de sa da. Na descri c ao feita a seguir, as primeiras duas variantes s ao descritas juntas. Suas formas s ao: INQUIRE({[UNIT=]|FILE=<arq>}[, IOSTAT=<ios>][, ERR=<err-label>] [, EXIST=<ex>][, OPENED=<open>][, NUMBER=<num>][, NAMED=<nmd>] [, NAME=<nam>][, ACCESS=<acc>][, SEQUENTIAL=<seq>][, DIRECT=<dir>] [, FORM=<frm>][, FORMATTED=<fmt>][, UNFORMATTED=<unf>][, RECL=<rec>] [, NEXTREC=<nr>][, BLANK=<bl>][, POSITION=<pos>][, ACTION=<act>] [, READ=<rd>][, WRITE=<wr>][, READWRITE=<rw>][, DELIM=<del>][, PAD=<pad>]) & & & & &
onde os especicadores entre chaves ({}) s ao excludentes; o primeiro deve ser usado no caso de INQUIRE por unidade e o segundo no caso de INQUIRE por arquivo. Neste u ltimo caso, <arq> e uma express ao escalar de caracteres cujo valor, ignorando quaisquer brancos posteriores, fornece o nome do arquivo envolvido, incluindo o caminho. A interpreta c ao de <arq> depende do sistema. Em um sistema Unix/Linux, o nome depende do caso. Um especicador n ao pode aparecer mais de uma vez na lista de especicadores opcionais. Todas as atribui c oes de valores aos especicadores seguem as regras usuais e todos os valores do tipo de caracteres, exceto no caso de NAME= s ao mai usculos. Os especicadores, cujos valores s ao todos escalares e da esp ecie padr ao s ao:
147
IOSTAT= <ios>, tem o mesmo signicado descrito no comando OPEN (se c ao 9.4). A vari avel <ios> eau nica denida se uma condi c ao de erro ocorre durante a execu c ao do INQUIRE. ERR= <err-label>, tem o mesmo signicado descrito no comando OPEN (se c ao 9.4). EXIST= <ex>, onde <ex> e uma vari avel l ogica. O valor .TRUE. e atribu do se o arquivo (ou unidade) existir e .FALSE. em caso contr ario. OPENED= <open>, onde <open> e uma vari avel l ogica. O valor .TRUE. e atribu do se o arquivo (ou unidade) estiver conectado a uma unidade (ou arquivo) e .FALSE. em caso contr ario. NUMBER= <num>, onde <num> e uma vari avel inteira ` a qual e atribu do o n umero da unidade conectada ao arquivo, ou -1 se nenhuma unidade estiver conectada ao arquivo. NAMED= <nmd>, NAME= <nam>, onde <nmd> e uma vari avel l ogica ` a qual o valor .TRUE. e atribu do se o arquivo tem um nome ou .FALSE. em caso contr ario. Se o arquivo tem um nome, este ser a atribu do ` a vari avel de caracteres <nam>. Este valor n ao e necessariamente o mesmo que e dado no especicador FILE=, se usado, mas pode ser qualicado de alguma forma. Contudo, em qualquer situa c ao e um nome v alido para uso em um comando OPEN subseq uente. Assim, o INQUIRE pode ser usado para determinar o valor real de um arquivo antes deste ser conectado. Dependendo do sistema, o nome depende do caso. ACCESS= <acc>, onde <acc> e uma vari avel de caracteres ` a qual s ao atribu dos um dos valores SEQUENTIAL ou DIRECT dependendo do m etodo de acesso para um arquivo que est a conectado e UNDEFINED se n ao houver conex ao. SEQUENTIAL= <seq>, DIRECT= <dir>, onde <seq> e <dir> s ao vari aveis de caracteres ` as quais s ao atribu dos os valores YES, NO ou UNKNOWN, dependendo se o arquivo puder ser aberto para acesso direto ou seq uencial, respectivamente, ou se isto n ao pode ser determinado. FORM= <frm>, onde <frm> e uma vari avel de caracteres ` a qual s ao atribu dos um dos valores FORMATTED ou UNFORMATTED, dependendo na forma para a qual o arquivo e realmente conectado, ou UNDEFINED se n ao houver conex ao. FORMATTED= <fmt>, UNFORMATTED= <unf>, onde <fmt> e <unf> s ao vari aveis de caracteres ` as quais s ao atribu dos os valores YES, NO ou UNKNOWN, dependendo se o arquivo puder ser aberto para acesso formatado ou n ao formatado, respectivamente, ou se isto n ao pode ser determinado. RECL= <rec>, onde <rec> e uma vari avel inteira ` a qual e atribu do o valor do tamanho do registro de um arquivo conectado para acesso direto, ou o tamanho m aximo do registro permitido para um arquivo conectado para acesso seq uencial. O comprimento e o n umero de caracteres para registros formatados contendo somente caracteres do tipo padr ao e dependente do sistema em caso contr ario. Se n ao houver conex ao, <rec> resulta indenido. NEXTREC= <nr>, onde <nr> e uma vari avel inteira ` a qual e atribu do o valor do n umero do u ltimo registro lido ou escrito, mais um. Se nenhum registro foi ainda lido ou escrito, <nr>= 1. Se o arquivo n ao estiver conectado para acesso direto ou se a posi c ao e indeterminada devido a um erro anterior, <nr> resulta indenido. BLANK= <bl>, onde <bl> e uma vari avel de caracteres ` a qual s ao atribu dos os valores NULL ou ZERO, dependendo se os brancos em campos num ericos devem ser por padr ao interpretados como campos de nulos ou de zeros, respectivamente, ou UNDEFINED se ou n ao houver conex ao ou se a conex ao n ao for para E/S formatada. POSITION= <pos>, onde <pos> e uma vari avel de caracteres ` a qual s ao atribu dos os valores REWIND, APPEND ou ASIS, conforme especicado no correspondente comando OPEN, se o arquivo n ao foi reposicionado desde que foi aberto. Se n ao houver conex ao ou se o arquivo est a conectado para acesso direto, o valor e UNDEFINED. Se o arquivo foi reposicionado desde que a conex ao foi estabelecida, o valor depende do processador (mas n ao deve ser REWIND ou APPEND exceto se estes corresponderem a verdadeira posi ` c ao).
148
9.11. Outros comandos de posicionamento
ACTION= <act>, onde <act> e uma vari avel de caracteres ` a qual s ao atribu dos os valores READ, WRITE ou READWRITE, conforme a conex ao. Se n ao houver conex ao, o valor e UNDEFINED. READ= <rd>, onde <rd> e uma vari avel de caracteres ` a qual s ao atribu dos os valores YES, NO ou UNKNOWN, dependendo se leitura e permitida, n ao permitida ou indeterminada para o arquivo. WRITE= <wr>, onde <wr> e uma vari avel de caracteres ` a qual s ao atribu dos os valores YES, NO ou UNKNOWN, dependendo se escrita e permitida, n ao permitida ou indeterminada para o arquivo. READWRITE= <rw>, onde <rw> e uma vari avel de caracteres ` a qual s ao atribu dos os valores YES, NO ou UNKNOWN, dependendo se leitura e escrita s ao permitidas, n ao permitidas ou indeterminadas para o arquivo. DELIM= <del>, onde <del> e uma vari avel de caracteres ` a qual s ao atribu dos os valores QUOTE, APOSTROPHE ou NONE, conforme especicado pelo correspondente comando OPEN (ou pelo valor padr ao). Se n ao houver conex ao, ou se o arquivo n ao estiver conectado para E/S formatada, o valor e UNDEFINED. PAD= <pad>, onde <pad> e uma vari avel de caracteres ` a qual s ao atribu dos os valores YES, caso assim especicado pelo correspondente comando OPEN (ou pelo valor padr ao); em caso contr ario, o valor e NO. Uma vari avel que e a especica c ao em um comando INQUIRE, ou est a associada com um, n ao deve aparecer em outra especicador no mesmo comando. A terceira variante do comando INQUIRE, INQUIRE por lista de E/S, tem a forma: INQUIRE(IOLENGTH=<comp>) <lista-sa da> onde <comp> e uma vari avel inteira escalar padr ao que e usada para determinar o comprimento de uma <lista-sa da> n ao formatada em unidades que dependem do processador. Esta vari avel pode ser usada para estabelecer se, por exemplo, uma lista de sa da e muito grande para o tamanho do registro dado pelo especicador RECL= de um comando OPEN, ou ser usado como o valor do comprimento a ser determinado ao especicador RECL=. Um exemplo de uso do comando INQUIRE e dado abaixo: LOGICAL :: EX, OP CHARACTER(LEN= 11) :: NAM, ACC, SEQ, FRM INTEGER :: IREC, NR ... OPEN(2, IOSTAT= IOS, ERR= 99, FILE= Cidades, STATUS= NEW, & ACCESS= DIRECT, RECL= 100) INQUIRE(2, ERR= 99, EXIST= EX, OPENED= OP, NAME= NAM, ACCESS= ACC, & SEQUENTIAL= SEQ, FORM= FRM, RECL= IREC, NEXTREC= NR) Ap os execu c ao bem sucedida dos comandos OPEN e INQUIRE, as vari aveis ter ao os seguintes valores: EX= .TRUE. OP= .TRUE. NAM= Cidades ACC= DIRECT SEQ= NO FRM= UNFORMATTED IREC= 100 NR= 1
9.11
Outros comandos de posicionamento
Outros comandos que exercem fun c oes de controle no arquivo, em adi c ao ` a entrada e sa da de dados, s ao fornecidos abaixo.
149
9.11.1
Comando BACKSPACE
Pode acontecer em um programa que uma s erie de registros sejam escritos e que, por alguma raz ao, o u ltimo registro escrito deve ser substitu do por um novo; isto e, o u ltimo registro deve ser sobrescrito. De forma similar, durante a leitura dos registros, pode ser necess ario reler o u ltimo registro, ou vericar por leitura o u ltimo registro escrito. Para estes prop ositos, Fortran fornece o comando BACKSPACE, o qual tem a sintaxe BACKSPACE([UNIT=][, IOSTAT=<ios>][, ERR=<err-label>]) onde e uma express ao inteira escalar padr ao que designa o n umero da unidade e os outros especicadores opcionais t em o mesmo signicado que no comando READ (se c ao 9.5). A a c ao deste comando e posicionar o arquivo antes do registro corrente, se houver. Se o comando for tentado quando o registro estiver no in cio do arquivo, nada ocorre. Se o arquivo estiver posicionado ap os um registro de nal de arquivo, este resulta posicionado antes deste registro. N ao e poss vel solicitar BACKSPACE em um arquivo que n ao exista, nem sobre um registro escrito por um comando NAMELIST. Uma serie de comandos BACKSPACE resultar a no retrocesso no n umero correspondente de registros.
9.11.2
Comando REWIND
De forma semelhante a uma releitura, re-escritura ou verica c ao por leitura de um registro, uma opera c ao similar pode ser realizada sobre um arquivo completo. Com este prop osito, o comando REWIND: REWIND([UNIT=][, IOSTAT=<ios>][ERR=<err-label>]) pode ser usado para reposicionar um arquivo, cujo n umero de unidade e especicado pela express ao escalar inteira . Novamente, os demais especicadores opcionais t em o mesmo signicado que no comando READ. Se o arquivo j a estiver no seu in cio, nada ocorre. O mesmo ocorre caso o arquivo n ao exista.
9.11.3
Comando ENDFILE
O nal de um arquivo conectado para acesso seq uencial e normalmente marcado por um registro especial, denominado registro de nal de arquivo, o qual e assim identicado pelo computador. Quando necess ario, e poss vel escrever-se um registro de nal de arquivo explicitamente, usando o comando ENDFILE: ENDFILE([UNIT=][, IOSTAT=<ios>][, ERR=<err-label>]) onde todos os argumentos t em o mesmo signicado que nos comandos anteriores. O arquivo e ent ao posicionado ap os o registro de nal de arquivo. Este registro, se lido subseq uentemente por um programa, deve ser manipulado usado a especica c ao END=<end-label> do comando READ sen ao a execu c ao do programa ir a normalmente terminar. Antes da transfer encia de dados, um arquivo n ao pode estar posicionado ap os o registro de nal de arquivo, mas e poss vel retroceder com os comandos BACKSPACE ou REWIND, o que permite a ocorr encia de outras transfer encias de dados. Um registro de nal de arquivo e automaticamente escrito sempre quando ou uma opera c ao de retrocesso parcial ou completo segue um opera c ao de escrita como a opera c ao seguinte na unidade; quando o arquivo e fechado por um comando CLOSE, por um novo comando OPEN na mesma unidade ou por encerramento normal do programa. Se o arquivo tamb em pode ser conectado para acesso direto, somente os registros al em do registro de nal de arquivo s ao considerados como escritos e somente estes podem ser lidos em uma conex ao de acesso direto subseq uente.
Indice Remissivo
Ambito Nomes, 118 R otulos, 118 COUNT, rotina intr nseca, 74 EXTERNAL, atributo e declara c ao, 98 SAVE, atributo e declara c ao, 103 FORALL, comando e construto, 62 WHERE, comando e construto, 57 INTENT, atributo e declara c ao, 84 Interfaces, 86 Gen ericas, 114, 117 INTRINSIC, atributo e declara c ao, 65 M odulos, 107 Dados globais, 108 Rotinas de, 111 Rotinas gen ericas, 114, 117 Matrizes Ajust aveis, 93 Aloc aveis, 59 Autom aticas, 95 Construtores de, 55 Express oes e atribui c oes, 49 Format assumida, 94 Se c oes de, 51 Tamanho assumido, 93 Terminologia, 45 Tipos derivados, 47 ONLY, op c ao, 107, 110 PRIVATE, atributo e declara c ao, 113 PUBLIC, atributo e declara c ao, 113 nseca, 78 RANDOM NUMBER, rotina intr RANDOM SEED, rotina intr nseca, 78 RESHAPE, rotina intr nseca, 56, 76 RETURN, comando, 84 Rotinas, 81 Argumentos, 83 Matrizes, 92 Opcionais, 91 Palavras-Chave, 88 Subprogramas como argumentos, 97 Tipos derivados, 92 Elementais, 106 Externas, 86 Gen ericas, 114 Internas, 83 150 Intr nsecas SINH, 68 Puras, 104 Recursivas, 101 Rotinas de m odulos, 111 Valor matricial, 98

Fortran

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Fortran

Transféré par

Droits d'auteur :

Formats disponibles

Introdu c ao ao Fortran 90/95

In cio: Janeiro de 2005.

Vers ao: 12 de abril de 2010

Impresso: 12 de abril de 2010

iii 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

7.10 7.11 7.12

7.15 7.16 7.17

Impresso: 12 de abril de 2010

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

Refer encias Bibliogr acas

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

As origens da Linguagem Fortran

ingl es: Central Processing Unit.

1.2. O padr ao Fortran 90

Cap tulo 1. Introdu c ao

Recursos novos do Fortran 90

Um resumo dos novos recursos e dado a seguir:

Recursos em obsolesc encia do Fortran 90

Os recursos em obsolesc encia do Fortran 90 s ao:

1.3. Uma revis ao menor: Fortran 95

Recursos removidos do Fortran 90

Uma revis ao menor: Fortran 95

Recursos novos do Fortran 95

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

Cap tulo 1. Introdu c ao

Recursos em obsolesc encia do Fortran 95

Recursos removidos do Fortran 95

O Fortran no S eculo XXI: Fortran 2003

o draft em: http://www.dkuug.dk/jtc1/sc22/open/n3661.pdf.

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

1.4. O Fortran no S eculo XXI: Fortran 2003

Recursos novos do Fortran 2003

Os principais recursos introduzidos pelo padr ao s ao:

Recursos em obsolesc encia do Fortran 2003

Recursos removidos do Fortran 2003

Cap tulo 1. Introdu c ao

O novo padr ao: Fortran 2008

Recursos novos do Fortran 2008

Coment arios sobre a bibliograa

1.7. Observa c oes sobre a apostila e agradecimentos

Observa c oes sobre a apostila e agradecimentos

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

2.1. Formato do programa-fonte

tipos de vari aveis suportados pelo Fortran 95 s ao discutidos no cap tulo 3.

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

Cap tulo 2. Formato do C odigo-Fonte

Nomes em Fortran 90/95

Entrada e sa da padr oes

2.4. Conjunto de caracteres aceitos

Caractere ! % & ; ? ** < >

Conjunto de caracteres aceitos

Autor: Rudi Gaelzer IFM/UFPel

Impresso: 12 de abril de 2010

Tipos de Vari aveis

Declara c ao de tipo de vari avel

3.2. Vari aveis do tipo INTEGER

Vari aveis do tipo INTEGER

Vari aveis do tipo REAL