apostila fortran curso inpe 2008 -...

Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)

Introdução à Linguagem

de Programação

Fortran 90

CPTEC/INPE (2008)


Sumário

Sumário ...........................................................................................................5

2. FORTRAN 77 ................................................................................................4

3. FORTRAN 90 ................................................................................................5

4. ESTRUTURA DE PROGRAMAS ..................................................................6

4.1 Recomendações de codificação......................................................................8

4.2 Regras de codificação ...................................................................................8

5. TIPOS E DECLARAÇÕES DE VARIÁVEIS..................................................9

5.1 Tipos de dados intrínsecos ............................................................................9

5.2 Comandos de especificação de atributos........................................................11

5.2.1 KIND ........................................................................................................11

5.2.2 PUBLIC e PRIVATE .................................................................................11

5.2.3 DATA ........................................................................................................12

5.2.4 PARAMETER ...........................................................................................12

5.2.5 DIMENSION.............................................................................................13

5.2.6 ALLOCATABLE .......................................................................................13

5.2.7 INTENT ....................................................................................................14

5.2.8 POINTER .................................................................................................14

5.3 Comandos de Especificação ..........................................................................15

5.3.1 COMMON ................................................................................................15

5.3.2 EQUIVALENCE .......................................................................................15

5.3.3 NAMELIST...............................................................................................16

5.3.4 SEQUENCE ..............................................................................................16

6. EXPRESSÕES E OPERADORES ..................................................................17

6.1 Alocação dinâmica de dados .........................................................................18

6.2 Operações envolvendo ponteiros...................................................................20

6.3 Operações envolvendo arranjos ....................................................................22

6.3.1 Manipulação condicional de um arranjo (WHERE... END WHERE)..........22

7. COMANDOS DE CONTROLE DE FLUXO E PROGRAMAÇÃO…………...ESTRUTURADA ..............................................................................................24

7.1 Estruturas de Controle .................................................................................24

7.2 Desvio Incondicional ....................................................................................24

7.2.1 GO TO ......................................................................................................24

7.3 Decisão.........................................................................................................26

7.3.1 Comandos IF... END IF..............................................................................26

7.3.2. Comando IF lógico....................................................................................26


7.3.4 Comandos IF bloco ....................................................................................27

7.3.5. Estruturas de IF bloco encaixados .............................................................29

7.3.6. Comando DO............................................................................................29

7.3.7 DO WHILE... END DO..............................................................................30

8. ENTRADA E SAÍDA DE DADOS ..................................................................31

8.1 Comandos de Entrada e Saída ......................................................................32

8.1.1 PRINT.......................................................................................................33

8.1.2 READ........................................................................................................34

8.1.3 WRITE .....................................................................................................35

8.1.4 OPEN........................................................................................................35

8.1.5 INQUERE .................................................................................................37

8.1.6 Comando Format e Especificações de Formato ..........................................40

9. SUBPROGRAMAS ........................................................................................40

9.1 Subrotinas ....................................................................................................41

9.2 Módulos .......................................................................................................43

REFERÊNCIAS BIBLIOGRÁFICAS ................................................................47

1. ANEXO A: FUNÇÕES INTRÍNSECAS..........................................................48

1. Funções Trigonométricas................................................................................48

2. Funções Genéricas .........................................................................................50

3. Exponenciais..................................................................................................50

4. Logaritmo ......................................................................................................50

5. Máximos ........................................................................................................51

6. Mínimos.........................................................................................................51

8. Raiz Quadrada de X.......................................................................................51

9. Truncamento de X..........................................................................................51

10. Arredondamento de X ..................................................................................52

11. Diferença Positiva Entre X e Y......................................................................52

12. Tipo de Dado................................................................................................52

13. Transformação do Tipo de X ........................................................................53

14.Complexos ....................................................................................................53

15. Caracteres ....................................................................................................54

16. Valores Absolutos de X .................................................................................54


1 – INTRODUÇÃO

1.1 Históricos da Linguagem Fortran

O surgimento dos computadores de uso geral, a partir de 1950, trouxe a necessidade de

serem utilizados de forma mais eficientes. A dificuldade existente na programação de computadores

até então, usando-se diretamente códigos binários – números escritos com os algarismos 0 e 1 – era

um dos principais entraves na utilização dos computadores.

Com isso, surgiu o conceito de linguagens de programação de alto nível. A primeira a surgir

foi a linguagem FORTRAN. Um grupo de pesquisadores da IBM, liderado por Jon Backus (Chiver

e Sleightholme, 2000) desenvolveu a linguagem entre 1954 e 1957. O resultado foi uma linguagem

que atendia as necessidades daqueles usuários que precisavam resolver problemas de cunho

científico, com uma significativa parcela de cálculo envolvida. O próprio nome da linguagem já

exibia essa característica: FORTRAN é uma corruptela de “FORmula TRANslation”.

Em 1966, quando a primeira versão padronizada da linguagem estava disponível,

FORTRAN já era a linguagem de escolha da comunidade científica. Dentre as principais

características que a linguagem exibia, destacam-se, como citado em (Chivers e Sleightholme,

2000): ampla disponibilidade de compiladores para diferentes computadores; facilidade para ensiná-

la; independência do computador; eficiência em muitas implementações; e demonstrava as

vantagens do uso de subrotinas e de compilação independente. Além dessas, destacamos a

simplicidade da linguagem, que colaborou para a sua disseminação a comunidade científica.

A linguagem foi modernizada a partir de 1970 e o novo padrão, FORTRAN 77, introduzia

algumas pequenas modificações na estrutura dos comandos, como o uso de blocos IF ... THEN ...

ELSE. No entanto, nessa época, existiam outras linguagens – como C, PASCAL, ADA e MODULA

– que haviam introduzido novos conceitos ou sedimentado outros, como a tipagem explícita de

variáveis; definição de novos tipos de dados, permitindo a criação de estruturas de dados mais

adequadas para resolver problemas; alocação dinâmica de dados; subprogramas recursivos; controle

de exceção (uma das principais características da linguagem ADA); e estabelecimento de módulos.

FORTRAN 77 não oferecia quaisquer desses recursos e, por isso, acabou sendo relegada quase que

a segundo plano.

Por meados da década de 1980, uma nova revisão da linguagem estava por vir. Batizada

então de FORTRAN 8X, ela viria a incorporar praticamente todos os outros conceitos já citados

(exceto a tipagem explícita e o controle de exceção). O processo de definição do novo padrão foi

demorado, porém permitiu que muitas das idéias a serem inseridas nesse padrão fossem

amadurecidas. Assim, surgiu a linguagem FORTRAN 90 (Adams et al., 1992) que, na visão do


autor, não perde em nada para linguagens como C e PASCAL, para os fins a que ela se destina.

Mais do que isso, ela incorpora mecanismos para manipulação de arranjos que não são oferecidos

em qualquer outra linguagem e que em muito auxiliam no desenvolvimento de programas

científico.

Em 1996, foi feita mais uma revisão da linguagem, chamada de FORTRAN 95 (Kerrigan,

1993; Gehrke, 1995), a qual incorporou pequenas modificações à linguagem FORTRAN 90,

motivada pela necessidade de aproximar o padrão à linguagem HIGH PEFORMANCE FORTRAN

– HPF, a qual é voltada para o uso de computadores de arquiteturas avançadas, vetoriais e/ou

paralelas. A linguagem HPF pode ser considerada uma extensão da linguagem FORTRAN 90 e,

atualmente muitos fabricantes oferecem compiladores HPF baseados na linguagem FORTRAN 90.

Desde 1997, a linguagem encontra-se em um novo processo de revisão. FORTRAN 2000

(ISO/IEC JTC1/SC22/WG5, 2003) incorporará uma série de novos comandos que permitirão, entre

outros, o controle de exceções e programação orientada a objetos. Essa revisão permitirá que a

linguagem se torne ainda mais utilizável pela comunidade científica.

2. FORTRAN 77

O Fortran77 foi considerado obsoleto em relação às linguagens atuais e aos recursos

existentes.

Razões:

• Formato fixo:

Linhas da posição 7 a 72;

Somente letras maiúsculas;

Nomes até 6 caracteres;

• Impossibilidade de representar operações paralelas intrínsecas;

É uma situação crítica, pois o Fortran é considerado com uma linguagem de alta

performance, no entanto, até o padrão 77 não existia nenhuma instrução que permitisse o

paralelismo, como compartilhamento de endereços de memória.

•Não é possível a alocação de memória dinâmica;

No Fortran77, o programador é obrigado a declarar vetores com o maior tamanho possível

para reservar memória durante a compilação.

• Não possui representação numérica portável;


A precisão de campos numéricos variava de uma máquina para outra, tornando o código

“não portável”.

• Não possui definição de tipo de dado pelo programador;

Não é possível criar novos formatos a partir dos existentes.

• Não possui recursão explícita;

Não é possível chamar uma função dentro de outra função.

Exemplo 2.1 de um programa em formato fixo (FORTRAN 77).

c 1 2 3 4 5 7

c234567890123456789012345678901234567890123456789012345678901234567890

PROGRAM TESTE

* este é um programa de teste

INTEGER :: I,J

REAL, ! este é um comentário

+DIMENSION(200,300) :: MATRIZ

MATRIZ = 100.0

END PROGRAM TESTE

3. FORTRAN 90

• Formato livre:

– 132 caracteres por linha;

– Maiúsculas e minúsculas;

– Nomes até 31 caracteres;

Mais de um comando por linha.

• Definição de “ARRAYS” paralelos;

Novos recursos na definição de um “ARRAY” permitem particionar vetores por entre vários

processos que compartilham um ambiente de memória compartilhada.

• Alocação de memória dinâmica e apontadores;

• Definição de tipo de dados (Comando KIND);


• Recursividade

Além dos recursos descritos acima, vários outros, melhoraram o Fortran tornando-o mais

atual aos recursos existente em outras linguagens:

§ Controles de estruturas:

- DO...ENDDO

- DO...WHILE

- SELECT CASE

§ Substituição de comandos:

- COMMON blocks à MODULE

- EQUIVALENCE à TRANSFER

§ Novos comandos:

- IMPLICIT NONE

Exemplo 3.1 de um programa em formato livre (FORTRAN 90)

PROGRAM teste

* este é um programa de teste

INTEGER :: I,J

REAL, & ! este é um comentário

DIMENSION(200,300) :: MATRIZ

MATRIZ = 100.0

END PROGRAM teste

4. ESTRUTURA DE PROGRAMAS

Inicialmente, cabe ressaltar que um programa de computador é um conjunto de instruções

escritas de acordo com as regras sintáticas de uma linguagem. Um programa ou código-fonte escrito

na linguagem FORTRAN 90 é composto por blocos, os quais definem as diferentes seções do

mesmo. Um programa FORTRAN 90 tem, no mínimo, uma seção chamada de programa principal,

a qual é composta por comandos não-executáveis (declarações e comentários) e executáveis, e é

englobada pelos comandos PROGRAM <nome-do-programa> e END PROGRAM <nome-do-

programa>. A estrutura básica de um programa FORTRAN 90 pode, então, ser descrita como:


PROGRAM <nome-do-programa>

[ <declarações> ]

[ <comandos-executáveis> ]

END PROGRAM <nome-do-programa>

Semântica:

1) <declarações> é um conjunto de comandos não executáveis que definem os dados e

subprogramas a serem usados no programa;

2) <comandos-executáveis> é um conjunto de comandos que serão executados, na ordem

em que aparecem listados e atendendo a quaisquer desvios em seu fluxo de execução,

conforme expresso pelo programador, valendo-se dos diferentes comandos de controle

de fluxo de execução.

Assim, o menor programa que pode existir em FORTRAN 90 é dado pelo exemplo abaixo.

Exemplo 4.1 Menor Programa possível.

PROGRAM MENOR_PROGRAMA

END PROGRAM MENOR_PROGRAMA

Além do programa principal, pode-se definir subprogramas (SUBROUTINE e FUNCTION) e

módulos. Um subprograma é dito interno quando o seu código pertence à outra seção (isto é, o seu

código-fonte é expresso após o comando CONTAINS dentro daquela seção), ou ele é externo,

quando o seu código-fonte for descrito separadamente – em outro arquivo ou dentro de um módulo.

Um módulo é uma seção englobada por MODULE <nome-do-módulo> e END MODULE <nome-

do-módulo>, o qual contém declarações de variáveis e tipos de dados e/ou um conjunto de

subprogramas, necessariamente externos a outras seções (programa principal e outros módulos).

O Fortran possui algumas regras bem definidas para ordem dos comandos:

• Cabeçalho de definição:

- PROGRAM, FUNCTION, SUBROUTINE, MODULE ou BLOCK DATA;

- Só pode haver um único comando PROGRAM.

- Pode haver mais de um FUNCTION, SUBROUTINE e MODULE.

- Só pode haver um único BLOCK DATA


• Comandos de Declaração:

- REAL, INTEGER, IMPLICIT, PARAMETER, DATA;

• Comandos de Execução:

- IF-ENDIF, DO-ENDDO, comando de atribuição;

• Finalização do programa com o comando END;

4.1 Recomendações de codificação

• Sempre utilize o comando IMPLICT NONE;

• Comandos, funções intrínsecas e as definidas pelo programador, devem se colocadas em

maiúsculas;

OBS: Não é obrigatório! Apenas uma recomendação.

• Variáveis e constantes em minúsculas;

OBS: Não é obrigatório! Apenas uma recomendação.

• Cada comando deve ser posto numa linha

• Codifique com recuos;

• Acrescente comentários às linhas.

4.2 Regras de codificação

• “Brancos” não são permitidos:

“Palavras-chave”

INTEGER :: nome1 Certo

INT EGER :: nome1 Errado

“Nomes”

REAL :: valor_total Certo

REAL :: valor total Errado

• “Brancos” são permitidos:

Entre “palavras-chave”

Entre “nomes” e “palavras-chave”

INTEGER FUNCTION val(x) Certo

INTEGERFUNCTION val(x) Errado

INTEGER FUNCTIONval(x) Errado

• Nomes de variáveis e rotinas:


Podem ter até 31 caracteres

Devem começar com letra

REAL :: a1 Certo

REAL :: 1a Errrado

Podem continuar com letras, digitos ou “_”

CHARACTER :: atoz Certo

CHARACTER :: a-z Errado

CHARACTER :: a_z Certo

5. TIPOS E DECLARAÇÕES DE VARIÁVEIS

A linguagem FORTRAN 90 apresenta um conjunto de diferentes tipos de variáveis,

predefinidos, capazes de armazenar números inteiros, reais e complexos, ou, ainda, valores lógicos

ou caractere. Além disso, FORTRAN 90 oferece ao programador a possibilidade de criar novos

tipos, permitindo criar diferentes estruturas de dados.

5.1 Tipos de dados intrínsecos

A linguagem FORTRAN 90 define seis tipos diferentes de dados intrínsecos, a saber:

INTEGER define variáveis do tipo inteiro, isto é, capazes de armazenar valores inteiros negativos,

positivos e zero;

REAL define variáveis do tipo real, isto é, capazes de armazenar valores reais negativos, positivos

e zero;

DOUBLE PRECISION define variáveis do tipo real, isto é, capazes de armazenar valores reais

negativos, positivos e zero, com uma precisão duas vezes superior àquela apresentada por variáveis

do tipo REAL (15 casas decimais mais ou menos);

COMPLEX define variáveis do tipo complexa, isto é, capazes de armazenar valores complexos

onde cada parte – real e imaginária – é um dado de tipo REAL;

LOGICAL define variáveis do tipo lógico, isto é, capazes de armazenar os valores .TRUE.

(verdadeiro) e .FALSE. (falso);

CHARACTER define variáveis do tipo caractere, isto é, capazes de armazenar um caractere ou um

conjunto de caracteres (uma string).


5.1.1 Declaração explícita e implícita de variáveis

Num bloco PROGRAM...END PROGAM, SUBROUTINE...END SUBROUTINE,

FUNCTION...END FUNCTION ou MODULE...END MODULE podem existir inúmeras

declarações de variáveis, de diferentes tipos, até que ocorra o primeiro comando executável no

bloco; a partir daí, não pode mais haver declarações de variáveis, até o fechamento do bloco.

Exemplo 5.1 Declaração de variáveis intrínsecas.

REAL :: X, Y, Z = 1.0REAL A, B, CREAL*8 :: U = 3.0 ! Uma variável REAL com 8 bytes de tamanhoDOUBLE PRECISION :: M = 100.0D0, N ! A parte exponencial deve ser separada por um ‘d’ ou

! ’D’ no lugar do ‘e’ ou ‘E’.DOUBLE PRECISION A, B, CINTEGER :: I = 4, J, KINTEGER F1, F2INTEGER(2) :: DOIS ! Uma variável INTEGER com dois bytes de tamanhoCOMPLEX :: EHO = (0.0, 3.0)COMPLEX U, V, WCHARACTER :: SIMBOLO = `%`CHARACTER TIPOCHARACTER(LEN=10) :: NOME = ‘JOSÉ SILVA’ ! Uma ‘string’ com 10 caracteresCHARACTER*13 :: NOME = ‘MANOEL CARLOS’LOGICAL :: ACHOU = .FALSE.LOGICAL PROCURE, FIM

Note que as declarações não contêm nenhum atributo, os quais serão apresentados

posteriormente. Nas versões anteriores do FORTRAN era possível utilizar variáveis sem ser

anteriormente declarado, o que é uma má técnica de programação, pois permite a ocorrência de

erros fatais. Feita essa advertência, é admitido em FORTRAN 90 utilizar variáveis sem ter sido

declarada, as quais seguem a seguinte regra:

Variável do tipo INTEGER – uma variável cuja primeiro caractere do seu nome seja I, J, K,

L, M ou N;

Variável do tipo REAL – uma variável cujo primeiro caractere de seu nome não seja nenhum

dos listados anteriormente.

A fim de evitar que tal regra seja utilizada pelo compilador da linguagem FORTRAN 90,

pode-se incluir em qualquer bloco, antes da declaração de variáveis, o comando IMPLICIT NONE,

o qual faz com que todas as variáveis utilizadas no bloco sejam declaradas, prevenindo a ocorrência

de erros como mencionado anteriormente.


5.2 Comandos de especificação de atributos

Um atributo é uma característica apresentada por um dado. Por exemplo, um vetor de dados

tem um atributo chamado DIMENSION; ou um argumento de um subprograma pode ser opcional, e

para tanto declara-se tal argumento com o seu tipo e com o atributo OPTIONAL. Os atributos

existentes na linguagem são apresentados a seguir:

5.2.1 KIND

Uma variável do tipo INTEGER, REAL, COMPLEX, DOUBLE PRECISION, LOGICAL

ou CHARACTER tem associada a si um KIND (ou gênero), que específica a quantidade de bytes

usados para representar aquela variável e caso não seja declarado será utilizado o KIND default que

pode mudar de compilador para compilador.

5.2.2 PUBLIC e PRIVATE

O atributo PUBLIC indica que uma variável declarada em um módulo é visível fora do

módulo, isto é, pode ser lida e alterada. O atributo PRIVATE indica que uma variável (ou parte de

um tipo) é visível apenas dentro de um módulo.

Exemplo 5.2 Uso do atributo PUBLIC

MODULE MODULO_AINTEGER, PUBLIC :: A, B = 3INTEGER C, DPUBLIC CCONTAINSSUBROUTINE SUB_1C = 2A = B + CD = 2*AEND SUBROUTINE SUB_1.

END MODULE MODULO_A

PROGRAM PRINCIPALUSE MODULO_AIMPLICT NONE

A = B+CCALL SUB_1D = 5+ D

END PROGRAM PRINCIPAL


Exemplo 5.3 Uso do atributo PRIVATE

MODULE MODULO_AINTEGER, PROVATE :: A, B = 3INTEGER C, DPRIVATE CCONTAINSSUBROUTINE SUB_1C = 2A = B + CD = 2*AEND SUBROUTINE SUB_1

END MODULE MODULO_APROGRAM PRINCIPALUSE MODULO_AIMPLICIT NONE

A = B + C ! Erro, variáveis A, B e C só existem dentro do módulo! MODULO_A


5.2.3 DATA

O atributo DATA serve para inicializar variáveis.

Exemplo 5.4 Uso do Atributo DATA

INTEGER, DIMENSION(4) :: U = (/1,2,9,16/)REAL :: X = 1.0, Y, K, Z = 5.0DATA Y, K /-1.0, 6.0/

No exemplo, U é um arranjo com uma dimensão, com quatro elementos, os quais foram

inicializados como U(1) = 1, U(2) = 2, U(3) = 9, U(4) = 16; X e Z são variáveis escalares, as quais

foram inicializadas como X = 1.0 e Z = 5.0; e Y e K foram declaradas como do tipo REAL, mas

foram inicializadas posteriormente com o atributo DATA, recebendo os valores -1.0 e 6.0,

respectivamente.

5.2.4 PARAMETER

O atributo PARAMETER indica que uma variável ao ser declarada não poderá ser modificada é

um meio de se representar uma constante por um símbolo, como na Matemática, em vez de

representá-la por um valor.


Exemplo 5.5 Uso do Atributo PARAMETER

INTEGER, PARAMETER :: M = 100, N = 20, NZ = M*N – M

REAL :: PI

PARAMETER (PI = 3.1415926)

Observe que a variável NZ é inicializada com uma expressão envolvendo M e N, cujos valores

foram definidos anteriormente.

5.2.5 DIMENSION

O atributo DIMENSION define uma variável como sendo um arranjo, isto é, uma matriz ou

vetor. Para definirmos um arranjo, especificamos os limites de indexação de cada uma de suas

dimensões. Permite especificar uma determinada variável como sendo uma variável indexada.

Exemplo 5.6 Declarações de arranjos.

REAL, DIMENSION(10) :: ADOUBLE PRECIOSION, DIMENSION(-1:2,2) :: BCOMPLEX, DIMENSION(20) :: C, XCHARACTER, DIMENSION(4) :: CODIGO

Observe que o arranjo CODIGO não é uma string de quatro caracteres, cada um dos quatro

elementos do arranjo pode armazenar apenas um caractere.

Exemplo 5.7 Rank e Shape de arranjos.

Considere as seguintes declarações:

REAL, DIMENSION(10) :: AREAL, DIMENSION(-4:5) :: BREAL, DIMENSION(5,6:20) :: C

o arranjo A tem rank igual a 1 e shape igual a (/10/); o arranjo B tem rank igual a 1 e shape igual

(/10/); e o arranjo C tem rank igual a 2 e shape igual a (/5,15/).

5.2.6 ALLOCATABLE

O atributo ALLOCATABLE indica que um arranjo será alocado dinamicamente, através do

comando ALLOCATE.


Exemplo 5.8 Uso do atributo ALLOCATABLE

COMPLEX, DIMENSION(:,:), ALLOCATABLE :: PONTOSREAL, DIMENSION (:) :: AALLOCATABLE A

5.2.7 INTENT

O atributo INTENT é usado para se especificar como é passado um argumento para um

subprograma (Subroutine) e como ele é retornado. Em outras palavras como a mensagem chega e

de onde chega e como ela sairá.

Exemplo 5.9 Uso do atributo INTENT

SUBROUTINE RETIRA_VALOR (A,B,C)INTEGER, INTENT(IN) :: AINTEGER, INTENT(OUT) :: BINTEGER, INTENT(INOUT) :: CINTEGER :: I, J

I = 2*aJ = 3*B – I !Erro, B é um argumento OUT e não teve um valor atribuído a ele antes de

! ser usadoC = I_J+KEND SUBROUTINE RETIRA_VALOR

5.2.8 POINTER

Um atributo POINTER indica que uma variável é um ponteiro, isto é, ela contém o endereço

de uma outra variável de mesmo tipo. Uma variavel do tipo POINTER não pode ser inicializada

nem tampouco pode ter os atributos: ALLOCATABLE, EXTERNAL, INTENT, INTRINSIC,

PARAMETER ou TARGET.

Exemplo 5.10 Uso do atributo POINTER

TYPE NODO_ARVORE_BINARIAINTEGER :: VAORTYPE (NODO_ARVORE_BINARIA), POINTER:: &

NODO_FILHO_ESQUERDO, &NODO_FILHO_DIREITA

END TYPE NODO_ARVORE_BINARIATYPE (NODO_ARVORE_BINARIA) :: RAIZPOINTER RAIZ

Nesse exemplo, utiliza-se um tipo definido pelo programador, o qual representa nodos d uma

árvore binária, cada nodo tem, além do valor armazenado nele, dois ponteiros para os seus nodos

filhos. Também é declarado um ponteiro do mesmo tipo que representa o nodo raiz.

OBS. Além desses comandos de especificações de atributos citados acima ainda existe os


comandos EXTERNAL, INTRINSIC, SAVE, OPTIONAL e TARGET que não será aqui abordado

por não serem tão usuais.

5.3 Comandos de Especificação

Em FORTRAN 90 é possível designar algumas variáveis com características comuns,

particularmente com relação à maneira como as mesmas são alocadas na memória do computador.

Essas características são especificadas através dos comandos COMMON, EQUIVALENCE,

IMPLICIT, NAMELIST e SEQUENCE.

5.3.1 COMMON

O comando COMMON especifica que variáveis declaradas em diferentes blocos,

possivelmente com nomes diferentes, ocupam os mesmos endereços na memória do computador.

Um exemplo típico é permitir que dados declarados no programa principal, sejam acessados e/ou

modificados por um subprograma (subroutine).

Exemplo 5.11 Uso do atributo COMMON

PROGRAM TESTEREAL :: A = 1.0, B = 2.0, CCOMMON /BLOCO1/ A, B

CALL SUBEND PROGRAM TESTE

SUBROUTINE SUBREAL :: U, VCOMMON /BLOCO1/ U, V

PRINT *, `U=`,U,` V=`V,END SUBROUTINE SUB

Um bloco COMMON, de nome BLOCO1, foi declarado no programa principal e na

subrotina. Assim, A e U são dois nomes diferentes para o mesmo endereço na memória; o mesmo

ocorre com B e V. Logo, ao se executar esse código, serão impressos os valores U=1.0 e V=2.0.

5.3.2 EQUIVALENCEO comando EQUIVALENCE especifica que variáveis declaradas em um mesmo bloco

ocupam o mesmo endereço na memória do computador.


Exemplo 5.12 Uso do atributo EQUIVALENCE

PROGRAM TESTEREAL :: A = 1.0, B = 2.0 C, DEQUIVALENCE (A, C), (B, D)

E = C+DEND PROGRAM TESTE

Nesse exemplo, as variáveis A e C ocupam o mesmo espaço endereço de memória (assim

como B e D ocupam outro endereço único). Dessa forma, ao referenciarmos C e D na expressão

cujo resultado será atribuído à variável E, é como se estivéssemos referenciando, de forma

equivalente, as variáveis A e B.

5.3.3 NAMELIST

O comando NAMELIST é usado para definir listas de variáveis que serão usadas,

posteriormente, em operação de entrada e saída de dados.

Exemplo 5.13 Uso do atributo NAMELIST

INTEGER A, BCHARACTER, DIMENSION(4) :: NOMEREAL XNAMELIST /LISTA1/ NOME, A, B, X

READ (*, LISTA1)

Uma NAMELIST chamada LISTA1 foi declarada, a qual contém quatro variáveis, NOME,

A, B e X. Ao executar o comando de leitura READ, o computador vai esperar que sejam inseridos

(através do teclado, usualmente) um conjunto de quatro caracteres, dois inteiros e um valor real, os

quais serão armazenados nas variáveis listadas na NAMELIST.

5.3.4 SEQUENCE

O comando SEQUENCE é usado dentro de uma declaração de um tipo definido pelo

usuário, e faz com que as partes componentes do tipo sejam alocadas na memória do computador na

seqüência em que são declaradas.

Exemplo 5.14 Uso do atributo SEQUENCE.

TYPE VETOR_3DSEQUENCEREAL :: X, Y, Z

END TYPE VETOR_3D


6. EXPRESSÕES E OPERADORES

• Símbolos aritméticos:

+ Adição

- Subtração

* Multiplicação

/ Divisão

** Potenciação

• Operadores Relacionais

Operador Definição Uso Significado

== ou .EQ. Igual a (equal) A==B ou A.EQ.B A é igual a B?

/= ou .NE. Diferente de (not euqal) A/=B ou A.NE.B A é diferente de B?

< ou .LT. Menor que (less than) A<B ou A.LT.B A é menor que B?

<= ou .LE. Menor ou igual (less or equal) A<=B ou A.LE. A é menor ou igual a B?

> ou .GT. Maior que (greater than) A>B ou A.GT.B A é maior que B?

>= ou .GE. Maior Igual (greater or equal) A>=B ou A.GE.B A é maior ou igual a B?

• Operador CARACTERE

• Utilizado para efetuar a concatenação “//”, somente de variáveis caracteres.

CHARACTER(LEN=*), PARAMETER :: string=‘abcdefgh’

string(1:1) à ‘a’

string(2:4) à ‘bcd’

a=string//string(3:5) à ‘abcdefghcde’

b=string(1:1)//string(2:4) à ‘abcd’

• Expressões Lógicas

Uma expressão lógica é usada para realizar um cálculo lógico.

Os "operadores lógicos" são (listamos somente os principais):

Operador Definição Uso Significado

.NOT. Negação .NOT.A Se A é verdade, .NOT.A é falso

.AND. Conjunção A.AND.B Para a expressão ser verdade, A e B precisam ser verdade

.OR. Disjunção A.OR.B Para a expressão ser verdade, A ou B, precisa ser verdade


Exemplos 6.1 Expressões e Operadores:

1) IF(x1 .EQ. x .AND. x2 .EQ. x1) THEN ...

2) fim = .FALSE.

DO WHILE ( .NOT. fim) ...

bloco de comandos

END DO

Regras para cálculos de expressões lógicas.

1. Parênteses podem ser usados e são calculados antes.

2. Os operadores aritméticos são calculados em segundo lugar.

3. Os operadores relacionais são calculados em terceiro lugar.

4. As operações lógicas são realizadas na seguinte ordem de precedência:

Operador Precedência

.NOT. Mais Alta

.AND. Intermediária

.OR. Mais Baixa

6.1 Alocação dinâmica de dados

A linguagem FORTRAN 90 introduziu mecanismos que permitem a alocação dinâmica de

dados na memória. Esse recurso é extremamente importante para a manipulação de certas estruturas

de dados, além de permitir a construção de bibliotecas de subprogramas que trabalham com a sua

própria área de dados, sem necessitar da intervenção do usuário.

Em FORTRAN 90, dois tipos de variáveis podem ser alocados dinamicamente: arranjos

declarados com atributo ALLOCATABLE e variáveis declaradas com atributo POINTER. Para

alocar variáveis na memória utiliza-se o comando ALLOCATE, cuja sintaxe é:

ALLOCATE ( < variável-1 > [ ( < seção > [,... [ < seção > ] ] ) ]

[ ,... , <variável-m> [ ( < seção > [ ,... [ < seção >] ] ) ] ] )

< seção > :: = <número-de-elementos> |

< índice-inicial > : <índice-final>


Semântica:

1) < variável-1 >, ..., < variável-m > são nomes de variáveis declarados com atributo

POINTER, ou de arranjos declarados com o atributo ALLOCATABLE;

2) < seção > pode ser um entre duas opções;

2.1) <número-de-elementos> é um número inteiro, que indica o número de elementos de

uma dimensão; nesse caso, os elementos ao longo daquela dimensão serão acessados por índices

entre 1 e <número-de-elementos>;

2.2) < índice-inicial > e <índice-final> indica que os elementos de uma dimensão serão

acessados por índices compreendidos entre < índice-inicial > e <índice-final>; o número de

elementos daquela dimensão será igual a < índice-inicial > - <índice-final> + 1.

Observe que uma variável com o atributo PONTEIRO pode simplesmente apontar para

outra variável, não havendo a necessidade de se alocar um espaço de memória para tal variável.

Porém, se for desejável atribuir valores a um apontador, então ele deve ser alocado anteriormente.

Sempre que uma variável tiver sido alocado dinamicamente, é interessante que ele seja

removida da memória, após não ser mais necessária seu uso. Para isso, utiliza-se o comando

DELLOCATE, cuja sintaxe é:

DELLOCATE ( < variável-1 > [,... , < variável-m > ] )

Semântica:

1) < variável-1>, ..., < variável-m> são nomes de variáveis declaradas com o atributo

POINTER, ou arranjos com o atributo ALLOCATABLE

Em certos computadores, pode acontecer um erro fatal no programa, ao terminar sua

execução, existam áreas de memória, alocadas dinamicamente, que não tenham sido desalocadas.

Além desses dois comandos, a linguagem oferece ainda o intrínseco ALLOCATED, o qual

permite verificar se uma variável foi alocada. O próximo exemplo ilustra o uso desses comandos.


Exemplo 6.1 Utilizando alocação dinâmica de memória.

PROGRAM TESTEINTEGER :: M, NREAL :: SOMA

PRINT*, `M = ?, N = ?`READ*,M,NSOMA = CALCULA_SOMA(M,N)PRINT*,`SOMA = `,SOMA

CONTAINSINTEGER FUNCTION CALCULA_SOMA(M,N) RESULT (X)INTEGER, INTENT(IN) :: M,NREAL, DIMENSION(:,:), ALLOCATABLE :: ARRINTEGER :: I,J

ALLOCATE(ARR(0:M-1,0:N-1))DO J = 0, N-1

DO I = 0, M-1ARR(I,J) = I+ J + M

END DOEND DOX = SUM(SQRT(ARR))DELLOCATE(ARR)

END FUNCTION CALCULA_SOMAEND PROGRAM TESTE

O programa lê duas variáveis, M e N, as quais são transmitidas à função ALCULA_SOMA.

Dentro dessa função, é alocado um arranjo ARR, com duas dimensões, através do comando

ALLOCATE(ARR(0:M-1,0:N-1)). A cada elemento do arranjo ARR é atribuído o resultado da

expressão I+ J + M, e X recebe o valor da soma das raízes quadradas de cada elemento do arranjo.

Ao final da função, o arranjo ARR é deslocado. Se, durante a execução desse programa, os valores

M e N forem 4 e 6, respectivamente, então o programa produzira a seguinte saída:

SOMA = 75.00000

6.2 Operações envolvendo ponteiros

Uma variável declarada com o atributo POINTER – um ponteiro – pode tanto apontar para

outra variável – ambas de mesmo tipo – ou, então, ser usada para alocar dinamicamente um espaço

de memória (com os comandos ALLOCATE e DELLOCATE). Nesse caso, o ponteiro não só

contem o endereço daquele espaço de memória, mas também contem valores.

Devido a essa característica “dual” dos ponteiros, é extremamente aconselhável que, antes

de utilizar um ponteiro, ele não aponte para qualquer posição de memória. Isso é feito através do

comando NULLFY.


Exemplo 6.2 Utilizando ponteiros.

PROGRAM TESTEIMPLICIT NONEINTEGER, POINTER :: P, QINTEGER, TARGET :: I = -10

NULLIFY(Q)Q=> IIF (ASSOCIATED(Q, TARGET=I)) THEN

PRINT*,`Q APONTA PARA I, Q=`,QELSE

PRINT*,`Q NÃO APONTA PARA I`END IF

NULLIFY(P)ALLOCATE(P)P = 5PRINT*,`P = `,PP => QPRINT*,`P= `,P

END PROGRAM TESTE

O programa declara duas variáveis do tipo INTEGER, P e Q, com o atributo POINTER;

além de uma variável do mesmo tipo, I, declarada com o atributo TARGET (o que indica que ela

poderá ser “apontada” por uma variável do tipo INTEGER e com o atributo POINTER). A variável

I é inicializada com o valor -10. Após, o ponteiro Q é anulada, através do comando NULLIFY(Q) e,

na seqüência, ele passa a apontar para I, com o comando Q => I.

Em seguida, é feito um teste para verificar se o ponteiro Q aponta para a variável I, através

do uso do intrínseco ASSOCIATED(Q, TARGET = I); caso seja verdadeiro (e, obviamente, o é), é

escrito o texto Q APONTA PARA I, Q =. Observe que foi utilizado o próprio ponteiro Q no

comando PRINT. Como Q aponta para I, o valor a ser impresso é aquele armazenado em I, qual

seja, -10.

Os comandos seguintes demonstram a característica dual de um ponteiro. Observe que, após

P ser anulado, ele é utilizando como argumento do comando ALLOCATE, efetivamente alocando

em espaço, de memória com 32 bits (já que variáveis do tipo INTEGER tem tamanho default de 4

bytes, isto é, KIND=4). Uma vez feito isso, pode ser atribuído um valor a P, através do comando P =

5; se o comando ALLOCATE(P), não tivesse sido executado (ou não estivesse presente), essa

atribuição não poderia ser feita (ocorrendo um erro de execução do tipo “acesso inválido a

memória”).

Após impressão do valor de P, esse ponteiro passa a apontar para outra posição de memória,

através do comando P => Q. São dois os efeitos desse comando:

1) O valor inteiro (5) armazenado em P não pode ser mais recuperado;


2) Como Q aponta para I, então também o ponteiro P aponta para I.

Assim, o valor impresso de P, ao final, é -10, que corresponde ao valor de I. Abaixo são

mostrados os valores impressos pelo programa.

Q APONTA PARA I,Q = -10P = 5P = -10

6.3 Operações envolvendo arranjos

6.3.1 Manipulação condicional de um arranjo (WHERE... END WHERE)

A linguagem FORTRAN 90 introduziu também a possibilidade de se efetuar a manipulação

de um arranjo de forma condicional, sem que necessariamente se acessem elementos individuais do

arranjo. Isso é feito usando-se o comando WHERE... END WHERE, cuja sintaxe é:

WHERE (< expressão–lógica-arranjo >)< comandos-verdadeiros >

[ ELSEWHERE< comandos-falsos >

END WHERE

Semântica:

1) <expressão–lógica-arranjo> é uma expressão lógica envolvendo pelo menos um arranjo;

2) <comandos-verdadeiros> é um conjunto de comandos da linguagem, nos quais um ou

mais arranjos serão possivelmente manipulados, desde que <expressão–lógica-arranjo> seja

satisfeita;

3) ELSEWHERE é uma palavra-chave opcional. Caso esteja presente, os <comandos-

falsos> serão executados, desde que <expressão–lógica-arranjo> não seja satisfeita;

4) o comando WHERE não pode ser aninhado, isto é, não pode aparecer como um dos

comandos em <comandos-verdadeiros> ou <comandos-falsos>.


Exemplo 6.3 Usando o comando WHERE... END WHERE

PROGRAM TESTEINTEGER, DIMENSION(O:3, O:3) :: MASCARAREAL, DIMENSION(4,4) :: ARRINTEGER :: N, I, J

CALL RANDON_NUMBER(ARR) ! Atribui valores pseudo-aleatórios a ARR

WRITE(*,`(“MATRIZ ALEATÓRIA:”)`)DO I = 1, 4

WRITE(*, `(4(F4.2,1X))`)(ARR(I,J),J = 1, 4)END DO

WHERE (ARR<0.5)MASCARA = 1

ELSEWHEREMASCARA = 0

END WHERE

WRITE(*,`(/”MATRIZ BINÁRIA:”)`)DO I = 0, 3

WRITE(*,`(4I2)`)(MASCARA(I,J), J = 0,3)END DO

END PROGRAM TESTE

O programa calcula uma matriz MASCARA, de tipo, INTEGER, a partir dos valores da

matriz ARR. Se algum elemento ARR(I,J) é menor do que 0.5, então o elemento correspondente

MASCARA(I,J) receberá o valor 1; caso contrario, esse elemento recebera o valor 0. Observe que

o arranjo MASCARA deve ter a mesma shape de A, apesar de que os índices podem ser diferentes;

nesse caso, é feita uma associação elemento a elemento entre cada arranjo. Um possível resultado

desse programa é:

MATRIZ ALEATÓRIA0.91 0.80 0.32 0.760.19 0.64 0.45 0.440.07 0.59 0.66 0.460.80 0.16 0.61 0.70

MATRIZ BINÁRIA0 0 1 01 0 1 11 0 0 10 1 0 0


7. COMANDOS DE CONTROLE DE FLUXO E PROGRAMAÇÃOESTRUTURADA

Normalmente, a execução dos comandos num programa é feita na ordem em que os

comandos são escritos: de cima para baixo, linha por linha, de acordo com a estrutura seqüencial.

Entretanto você pode usar comandos para transferir o controle de fluxo para outra parte da mesma

unidade de programa ou para outra unidade de programa. O controle pode ser transferido somente

para um comando executável.

Por vezes, um comando pode ser identificado por um "número de comando", consistindo de

um número inteiro, escrito antes do comando, no início da linha. Cada número de comando deve ser

único dentro da unidade de programa. Eles servem principalmente para a especificação de formatos

de entrada e/ou saída de dados. Evita-se hoje o uso antigo do número de comando, que servia de

referência para uma transferência de controle de fluxo. Isto favorece a criação de códigos de

programa "espaguete", sendo que o controle de fluxo pode ser mudado de maneira absurda,

dificultando e inviabilizando a manutenção dos programas.

7.1 Estruturas de Controle

As estruturas básicas de controle são:

1. Estrutura seqüencial.

2. Estrutura de tomada de decisão (IF-THEN-ELSE IF-ELSE-ENDIF).

3. Estrutura de laço:

- faça - enquanto (WHILE-LOOP).

- Estrutura de laço repetição (REPEAT-LOOP).

4. Estrutura de seleção de caso (SELECT CASE).

7.2 Desvio Incondicional

7.2.1 GO TO

O comando GO TO < rótulo > faz com que o fluxo de execução do programa seja desviado

incondicionalmente para o comando identificado por < rótulo >, o qual é um número inteiro,

colocado a frente do comando e separado do mesmo por no mínimo um espaço em branco, para um

código-fonte em formato livre, ou nas colunas 1 a 6 de uma linha, em formato fixo.


Exemplo 7.1 Uso do GO TO

I = 1J = I + 1K = I + JGO TO 100K = 1 ! Esse comando nunca será executado

100 PRINT *, `K=`,K

Nesse exemplo, K terá o valor 3, pois a atribuição k = 1 jamais será executada. Em uma

situação como essa os compiladores otimizadores não irão gerar código executável para tal

comando, uma vez que se garante que nunca será executado.

O comando GO TO jamais deve ser usado para se desviar do fluxo de execução de um

programa, se tal desvio pode ser obtido com outras construções existentes na linguagem, como, por

exemplo, comandos de repetição. É admitido, no entanto, que se utilize o GO TO em situações

como o tratamento de execuções (por exemplo, para evitar uma possível divisão por zero), ou para

consistência dos dados, desde que o fluxo de execução do programa seja desviado apenas para um

único comando, abaixo do GO TO. Com essas regras, é possível utilizar o GO TO de forma a

manter a legibilidade do programa. O exemplo a seguir ilustra o exposto:

Exemplo 7.2 Uso do GO TO para tratamento de exceção.

PROGRAM EXEMPLO...

AR = MUTMUL(A,R) ! Calcula o produto matriz*vetor entre a matriz A e o vetor R.RR = DOT_PRODUCT(R,R) !Calcula o produto interno de R com ele próprio.

RAR = DOT_PRODUCT(R,AR) !Calcula o produto interno de R com ARIF (RAR == 0.0) THEN

ERRONUM = 1GO TO 9999

END IFALPHA = RR/RARX = X + ALPHA*DR = R – ALPHA*AR…RRO == RR !Salva o valor anterior de RR em RRORR = DOT_PRODUCT(R,R)IF (RR == 0.0) THEN

ERRONUM = 2GO TO 9999

END IFBETA = RR/RRO…9999 PRINT*,`X=`,X,` ERRONUM=`,ERRONUMEND PROGRAM EXEMPLO


Observe que ambos os comandos GO TO desviam o fluxo de execução de programa para

apenas um comando, identificado pelo rotulo 9999, e esse comando encontra-se abaixo dos demais.

7.3 Decisão

7.3.1 Comandos IF... END IF

Os comandos IF transferem o controle do fluxo ou executam outro comando (ou um bloco

de comandos) dependendo do resultado verdadeiro ou falso de uma expressão lógica contida no

particular comando IF. Os três tipos de comandos IF são:

1. IF aritmético.

2. IF lógico.

3. IF bloco.

Os comandos ELSE, ELSE IF e END IF são também apresentados nesta seção, pois eles são

usados somente em conjunto com um comando IF bloco.

7.3.2. Comando IF lógico

O comando IF lógico calcula uma expressão lógica/relacional e executa ou ignora um

comando executável contido no próprio IF, dependendo do valor (falso ou verdadeiro) dessa

expressão.

A forma geral do comando IF lógico é:

IF (e) c

sendo que:

"e" é uma expressão lógica ou relacional.

"c" é o comando que será executado caso a expressão seja verdade; "c" não pode ser um

comando DO.

Vejamos como fica o fluxo do programa quando este chega a estas três linhas:

x=a-bIF(a .EQ. b) x=a+b

y=x**2

Observe que nas últimas 2 linhas temos três comandos:

1) IF(a .EQ. b)

2) x=a+b

3) y=x**2


Então:

a) Se de fato a=b, teremos a seguinte ordem de execução: 1 >> 2 >> 3.

b) Se, por outro lado, a é diferente de b, teremos a ordem de execução: 1 >> 3.

Exemplo 7.3 Uso do IF lógico.

IF ((K>KMAX) .OR. (ABS(X)<1.OE-5)) FIM = .TRUE.PRINT*,`K=`,K

7.3.4 Comandos IF bloco

O comando IF bloco permite a execução de um determinado bloco de comandos,

dependendo do valor da(s) expressões lógica(s)/relacional(is) nele contido.

A forma geral do comando IF bloco é:

IF (e1) THENbloco1

ELSE IF (e2) THENbloco2

ELSE IF (e3) THENbloco3

ELSEbloco n

END IF

sendo que e1, e2,e3, ... são expressões lógicas/relacionais. Deve ficar claro que somente um dos

blocos de comandos será executado.

O menor IF bloco é a estrutura:

IF (e) THENbloco

END IF

Vemos que os comandos ELSE IF e ELSE são opcionais.

O comando IF THEN permite a execução condicional de um bloco de comandos

executáveis. É obrigatório usar em conjunção o comando ENDIF para fechar o

comando.

A forma geral do comando IF THEN é:

IF (e) THEN

sendo que "e" é uma expressão lógica/relacional (portanto produzindo um resultado verdadeiro ou

falso).

Se a expressão "e" for verdadeira, a execução passa para o próximo comando executável

e daí para o comando ENDIF. Se for falsa, o controle é transferido para o próximo


comando: ELSE IF THEN, ELSE ou ENDIF.

O comando ELSE fornece uma rota alternativa para um comando IF THEN ou ELSE IF

THEN. Sua forma geral é simplesmente:

ELSE

O comando ELSE IF THEN combina as funções dos comandos ELSE e IF THEN, pois

fornece uma rota alternativa e torna possível uma estrutura IF bloco com mais de uma

alternativa.

Aforma geral do comando ELSE IF THEN é:

ELSE IF (e) THEN

sendo que "e" é uma expressão lógica/relacional.

Se a expressão for verdadeira, o controle passa para o próximo comando executável e daí

para o comando ENDIF. Se for falsa, passa para o próximo comando ELSE IF THEN,

ELSE ou ENDIF.

O comando ENDIF ou END IF finaliza uma estrutura IF bloco. Sua forma geral é

simplesmente:

END IF

Exemplo 7.4 Aninhamento de blocos IF... END IF

PRINT *,'Digite a nota do aluno: 'READ *,notaIF(nota>=5.0) THEN

PRINT *,'O aluno foi aprovado.'ELSEIF(nota>=3.5) THEN

PRINT *,'O aluno foi reprovado mas poderá cursar o RE.'ELSE

PRINT *,'O aluno foi reprovado e não poderá cursar o RE.'END IF


7.3.5. Estruturas de IF bloco encaixados

Um bloco de comandos executáveis dentro de um comando IF bloco pode conter outra

estrutura IF bloco. E isto pode se repetir indefinidamente.

Exemplo 7.5 Encadeamento de blocos IF... EDN IF.

PRINT *,'Digite a nota do aluno: 'READ *,notaIF(nota>=5.0) THEN

IF(nota>=9.5) THENPRINT *,'O aluno foi aprovado com louvor.'

ELSEIF(nota>=8.0) THENPRINT *,'O aluno foi aprovado com distinção.'

ELSEPRINT *,'O aluno foi aprovado.'

END IFELSEIF(nota>=3.5) THEN

PRINT *,'O aluno foi reprovado mas poderá cursar o RE.'ELSEPRINT *,'O aluno foi reprovado e não poderá cursar o RE.'

END IF

7.3.6. Comando DO

O comando DO é um comando de controle que permite que um bloco de comandos seja

repetitivamente executado. O número de execuções depende da variável de controle.

A forma geral do comando DO é:

DO v = vi , vf [, incr]

sendo que:

"v" é a variável do controle do laço DO.

"vi" é o valor inicial de v.

"vf" é o valor final ou máximo de v.

"incr" é o incremento de v. Se for omitido, é suposto como de valor 1.

O comando ENDDO ou END DO finaliza uma estrutura DO. Sua forma geral é

simplesmente:

END DO


Exemplo 7.6 Uso do DO... END DO finito.

PROGRAM EXEMPLOINTEGER, PARAMETER :: M = 6INTEGER, PARAMETER :: N =2INTEGER :: I, J, KREAL, DIMENSION(M,N) :: AREAL, DIMENSION(M) :: U = 0.0REAL, DIMENSION(N) :: V

K = 1Inicializa: DO J = 1, N

V(J) = JDO I = 1, M

A(I,J) = KK = K + 1

END DOEND DO inicializa

PRINT*,`V=`,VImprime: DO I = 1, M

WRITE(*,*)(A(I,J),J = 1, N)END DO

DO J = 1, NAltera: DO I = 1, M, 2

U(I) = U(I) + A(I,J) * V(J)END DO altera

END DOPRINT*,Ù=`,U

Nesse exemplo, o vetor V é inicializado como V(1) = 1, V(2) = 2 e a matriz A é inicializada

como A(1,1) = 1, A(2,1) = 2, ..., A(6,1) = 6, A(1,2) = 7, A(2,2) = 8, ..., A(6,2) = 12. O vetor U é

inicializado com 0.0, na sua declaração, e apenas os seus elementos U(1), U(3), U(5) serão

modificados dentro do laço altera, uma vez que esse laço tem como < valor-passo >=2. Ao final, o

vetor U terá os seguintes valores:

U(1) = 15.0, U(2) = 0.0, U(3) = 21.0, U(4) = 0.0, U(5) = 27.0, U(6) = 0.0.

Observe, também, o uso do laço imprime, o qual imprime os elementos da matriz, por

linhas, combinado com um laço implícito no comando WRITE, para imprimir todas as colunas de

uma linha.

7.3.7 DO WHILE... END DO

A estrutura DO WHILE - END DO (while loop) executa o laço finito de interações DO,

enquanto uma expressão lógica/relacional for verdadeira:


Exemplo 7.7 uso do DO WHILE... END DO

PROGRAM TESTEINTEGER, PARAMETER :: KMAX = 100INTEGER :: K = 0REAL :: A = 0.5REAL :: X = 1.0REAL :: X0LOGICAL :: CONVERGIU = .FALSE.

repete: DO WHILE ((K<=KMAX).AND.(.NOT. CONVERGIU))X0 = XX = X – A*XCONVERGIU = ABS(X-X0)<1.0E-5XK = K + 1

END DO repeteEND PROGRAM TESTE

O laço DO WHILE... END DO contem uma condição lógica composta: os comandos

contidos dentro do laço serão continuamente executados enquanto não excederem o Maximo de

interações permitidas e não for satisfeito o critério de convergência, ABS(X-X0)<1.0E-5. Ao

executar esse trecho de programa, teremos os seguintes valores para as variáveis envolvidas: K =

17, CONVERGIU = .TRUE., X0 = 1.525879E-05, X = 7.629395E-06.

O comando DO implícito é uma terceira forma do comando DO e somente pode ser usado

em comandos de entrada ou saída de dados.

Exemplos de uso do comando DO implícito:

PRINT *,(var(i),i=1,10,1)

PRINT *,(var(i,j),j=10,20,2)

READ(1,100)(var(i),i=2,8,2)

WRITE((3,200)(var(i,j),j=1,5,1)

8. ENTRADA E SAÍDA DE DADOS

Os "Comandos de Entrada" fornecem um método de transferir dados de um dispositivo

periférico (como um teclado) ou de um arquivo interno para a memória principal. Este processo é

chamado de "leitura de dados". Os "Comandos de Saída" fornecem um meio de transferir dados da

memória principal para um dispositivo periférico (como um monitor de vídeo ou impressora) ou um

arquivo interno. Este processo é chamado de "escrita" ou "gravação" de dados. Alguns comandos de

E/S permitem que se editem os dados durante a sua transferência. Neste capítulo somente serão

apresentados os comandos de E/S que transferem dados (READ, PRINT, WRITE). Comandos


auxiliares não serão discutidos.

Um "caractere" é um único símbolo, tal como a letra z, o dígito 4 ou um asterisco *. Um

"campo" é uma sucessão de caracteres, que representa alguma informação, tal como ANTONIO ou

128.47. Um "registro" é um grupo de campos que reúne informações sobre um único item, tal

como:

ANTONIO 26-01-1937 6543.21

(nome) (data nasc.) (salário)

Um "arquivo" é um grupo de registros, tal como:

A N T O N I O 2 6 - 0 1 - 1 9 3 7 6 5 4 3 . 2 1

A R N A L D O 2 2 - 1 0 - 1 9 4 5 9 8 7 . 6 5

M . C R I S T I N A 0 7 - 0 9 - 1 9 4 2 1 2 3 4 . 5 6

Temos acima um arquivo, com três registros, cada registro com três campos e comprimento

total de 27 caracteres. Cada comando de E/S opera sobre um único registro. Uma unidade de E/S é

um meio de se referir a um arquivo. Usam-se números de unidades de E/S para distinguir um

arquivo de outro. Certos números de unidades podem ser pré-definidos. Assim, por exemplo, o

número 5 pode indicar o teclado e 6 pode indicar o monitor de vídeo. O comando OPEN estabelece

a conexão entre o número da unidade e um particular arquivo.

8.1 Comandos de Entrada e Saída

Existem três comandos de leitura e escrita – READ (leitura), PRINT e WRITE (escrita).

Além desses, existem comandos para se manipular arquivos externos de dados, como OPEN,

CLOSE, INQUIRE, REWIND, BACKSPACE e ENDFILE.

Para definir de qual dispositivo será feita uma operação de entrada e saída, é necessário que

se especifique o mesmo. Em FORTRAN 90, existe predefinidos um dispositivo padrão de entrada –

o teclado – e um de saída – o monitor de vídeo.


8.1.1 PRINT

O comando PRINT permite que se escreva um conjunto de valores no dispositivo padrão de

saída.

Exemplo 8.1 Comando PRINT.

PROGRAM PRONCIPALIMPLICIT NONEINTEGER :: A = 12323, B = 64652545REAL, DIMENSION(2,2) :: XNAMELIST /DADOS/ B, A

X(1,:) = (/1.45656, 3.2367 /)X(2,:) = (/-9.435, 3.456 /)PRINT *,`A=`,A,` B=`,BPRINT `(I5,I7),`,A, BPRINT DADOSPRINT *, ((X(I,J), J=1,2),I=1,2)PRINT `(2F8.5)`, ((X(I,J),J=1,2),I=1,2)

END PROGRAM PRINCIAPL

O programa, ao ser executado, produziria o seguinte resultado:

A = 12323 B = 6465254512323*******& DADOSB = 64652545,A = 12323/1.456560 3.236700 -9.435000 3.4560001.45656 3.23670-9.435000 3.45600

Note que, na segunda linha impressa, o valor da variável B foi substituído por 7 caracteres *;

isso indica que o formato utilizado, I7, o qual especifica um tamanho de campo de apenas 7 dígitos

inteiros, é pequeno demais para conter o valor 64652545. Observe, também, a maneira como a lista

DADOS foi impressa. Os dois últimos comandos PRINT exemplificam o uso do comando DO para

gerar uma lista implícita de valores a serem impressos. Observe que, ao não especificar um formato,

os valores da matriz x são impressos seqüencialmente na mesma linha; a fim de formatarmos a

saída, o ultimo comando PRINT utiliza o formato 2F8.5, o que especifica que serão impressos

apenas 2 valores reais por linha, cada um ocupando um campo de tamanho 8 caracteres (incluindo o

ponto decimal) e com cinco casas decimais.


8.1.2 READ

O comando READ permite que se leia um conjunto de valores de um dispositivo de entrada.

O comando READ transfere dados de entrada para a memória de trabalho. IMPORTANTE: cada

novo comando READ passa a ler dados em uma nova linha.

Exemplo 8.2 Comando READ

PROGRAM PRINCIPALIMPLICIT NONEINTEGER :: A, B, C, ICHARACTER(LEN=13) :: BUFFER = 1 9876 1234 99`REAL, DIMENSION(4) :: RESULTADONAMELIST /DADOS/ A, B, C

READ (BUFFER, FMT=`(2I5)`)A, BREAD (BUFFER,`I2`)CPRINT DADOSREAD (*,`(2F4.2)`) (RESULTADOS(I), I=1,4)PRINT*,RESULTADOS



& DADOSA = 9876,B = 1234,C = 9/

ou seja, foram lidos três valores inteiros, os quais encontravam-se armazenados numa string decaracteres BUFFER. Após, o programa aguardar que se digite 4 valores reais, dois a cada fez; cadavalor tem um tamanho de 4 caracteres, com duas casas decimais. Assim se digitarmos

0.457.68 1.237.90

(após cada linha, tecla-se ENTER) o arranjo RESULTADOS terá os valores

0.4500000 7.680000 7.900000

Observe que, devido ao formato especificado no comando READ, os números são digitadossem espaço em branco entre eles.


8.1.3 WRITE

O comando WRITE permite que se escreva um conjunto de valores num dispositivo de

saída.

Exemplo 8.3 Comando WRITE

PROGRAM PRINCIPALIMPLICIT NONEINTEGER :: A=12323, B=64652545, I, JREAL, DIMENSION(2,2) :: XNAMELIST //DADOS/ B, A

X(1,:) = (/1.45656, 3.2367 /)X(2,:) = (/-9.435, 3.456 /)WRITE (*,*)À=`,A,` B=`,BWRITE (*,`(I5,I7)`)A, BWRITE (*,NML=DADOS)WRITE (*,*) ((X(I,J), J=1,2),I=1,2)WRITE (*,FMT=`(2F8.5)`), ((X(I,J),J=1,2),I=1,2)



A = 12323 B = 6465254512323*******& DADOSB = 64652545,A = 12323/1.456560 3.236700 -9.435000 3.4560001.45656 3.23670-9.435000 3.45600Observe que esse programa produz o mesmo resultado do que aquele obtido usando o

comando PRINT, mostrado no exemplo 8.1.

8.1.4 OPEN

O comando OPEN permite que se associe um arquivo externo a uma unidade, para se

realizar uma operação de entrada, saída, ou ambos. Sua sintaxe é a seguinte:

OPEN ( [UNIT] <unidades>

[ , ACCESS= `DIRECT` | `SEQUENTIAL` ]

[ , ACTION= `READ` | `WRITE` | `READWRITE`]

[ , BLANK= `NULL` | `ZERO`]

[ , DELIM= ÀPOSTROPHE` | `QUOTE` | `NONE` ]

[ , ERR= <RÓTULO> ]

[ , FILE= `FORMATTED` | ÙNFORMATTED` ]

[ , IOSTAT= <resultado> ]

[ , PAD= `YES` | `NO` ]


[ , POSITION= ÀSIS` | `REWIND` | ÀPPEND` ]

[ , RECL= <tamanho-registro> ]

[ , STAUTS= ÒLD` | `NEW` | `SCRATCH` | `REPLACE`]

[ , ÙNKNOWN` ] )

Semântica:

1) <unidade> é um numero inteiro maior ou igual a zero que identifica um arquivo externo;

2) ACESS indica o tipo de acesso a um arquivo; seqüencial (default) ou direto (isto é, um

comando READ ou WRITE pode ser usado com o atributo REC);

3) ACTION indica como o arquivo será aberto, se para leitura, escrita, ou para leitura e

escrita;

4) BLANK indica como são tratados espaços em brancos ao serem lidos, um dado.

BLANK= `NULL` é o default e significa que qualquer espaço em branco devem ser

considerados como zeros;

5) DELIM índia qual caractere é utilizado para separar os dados; DELIM=

ÀPOSTROPHE` indica o uso do caractere `, DELIM= `QUOTE` indica o caractere “ e

DELIM= `NONE` indica que nenhum caractere é usado (default);

6) ERR indica que, caso ocorra erro, o fluxo de execução do programa será desviado para o

comando identificador por <rótulo>;

7) FILE faz a associação entre o nome do arquivo externo e o numero da unidade; o nome é

o valor do string <nome-arquivo>, podendo ser uma variável ou uma constante o tipo

CHARACTER; caso não seja informado, serão utilizados os nomes default UNIT0,

UNIT1...;

8) FORM indica se o arquivo é formatado ou não; para arquivos com ACCESS =

`SEQUENTIAL, o default é FORM = `FORMATTED`; para arquivos com ACCESS =

`DIRECT`, o default é FORM = ÙNFORMATTED`;

9) Ao usar o atributo IOSTAT, o resultado do OPEN será armazenado na variável inteira

<resultado>; o valor -1 indica fim de arquivo encontrado, e qualquer outro valor é o

numero identificador de um erro, dependente da implementação;

10) PAD informa se os dados lidos serão completados com espaços em branco (PAD

=`YES`), caso o formato estabelecido para a leitura tenha um tamanho maior do que

existe (default);

11) POSITION indica a posição do arquivo para acesso seqüencial:

POSITION = ÀSIS` é o default, isto é, a posição de um arquivo já associado a uma

unidade não é alterado, enquanto arquivos novos sempre estão posicionados no inicio;


POSITION = `REWIND` faz com que o arquivo seja posicionado para o seu inicio;

12) RECL = <tamanho-registro> informa o tamanho do registro (em bytes) de um arquivo de

acesso direto, ou o maior tamanho de um registro num arquivo de acesso seqüencial; este

atributo é requerido para arquivos abertos com ACCESS = `DIRECT`;

13) STATUS descreve como o arquivo é aberto:

STATUS = `OLD` indica que o arquivo já existe (se não existe, ocorrera um erro);

STATUS = `NEW` indica que o arquivo será criado pelo programa (se já existir, ocorrera

um erro);

STATUS = `SCRATCH` indica que o arquivo será criado pelo programa, porem de

forma temporária; ele será removido quando a unidade sofrer um comando CLOSE ou

quando o programa terminar;

STATUS = `REPLACE` indica que um arquivo já existente terá o seu conteúdo

modificado pelo programa; caso o arquivo não exista, ele será criado;

STATUS = `UNKNOWN` indica que , se um arquivo já existir, ele será aberto; se não

existir, um novo arquivo será criado.

8.1.5 INQUERE

O comando INQUIRE permite que se obtenham informações sobre um arquivo externo.

INQUIRE ( [UNIT=] <unidade> | FILE= <nome-arquivo> |

IOLENGTH= <iolength>[, ACCESS= <acesso> ][, ACTION= <ação> ][, BLANK= <espaços> ][, DELIM= <delimitador> ][, DIRECT= <acesso> ][, ERR= <rótulo> ][, EXIST= <situação> ][, FORM= <forma> ][, FORMATTED= <formatado> ][, IOSTAT= <resultado> ][, NAME= <nome> ][, NAMED= <nomeado> ][, NEXTREC= <registro> ][, NUMBER= <número> ][, OPENED= <situação> ][, PAD= <situação> ][, POSITION= <posição> ][, READ= <situação> ][, READWRITE= <situação> ][, RECL= <tamanho> ][, SEQUENTIAL= <situação> ][, UNFORMATTED= <situação> ]


[, WRITE= <situação> ] )

Semântica:

1) <unidade> é um número inteiro maior ou igual a zero que identifica um arquivo externo,ou *;

2) FILE é o nome de um arquivo externo, o nome é o valor da string <nome-do-arquivo>,podendo ser uma variável ou uma constante do tipo CHARACTER; caso nãoseja informado, serão utilizados os nomes default UNIT0, UNIT1,...;

3) IOLENGTH é um numero inteiro que indica o tamanho de uma lista de saída;4) ACCESS retorna uma string informando se o acesso é seqüencial (`SEQUENTIAL`) ou

direto (`DIRECT`); caso o arquivo ainda não tenha sido associado a uma unidade atravésdo comando OPEN, o resultado é ÙNDEFINED`;

5) ACTION retorna uma string informando se o arquivo foi aberto para leitura(ÀCTION`), escrita (`WRITE`) ou leitura e escrita (`READWRITE`); caso o arquivoainda não tenha sido associado a uma unidade através do comando OPEN, o resultado éÙNDEFINED`;

6) BLANK retorna uma string informando como são tratados os espaços em branco, sedesconsiderados (`NULL`) ou como zeros (`ZEROS`); caso o arquivo ainda não tenhasido associado a uma unidade através do comando OPEN, ou ele não foi aberto parasaída formatada, o resultado é ÙNDEFINED`;

7) DELIM retorna uma string informando quais delimitadores são usados: nenhum(`NONE`), apostrofo (ÀPOSTROPHE`) ou aspas (`QUOTE`); caso o arquivo ainda nãotenha sido associado a uma unidade através do comando OPEN, o resultado éÙNDEFINED`;

8) DIRECT retorna uma string informando se o arquivo foi aberto para acesso direto(`YES`), ou não (`NO`); caso o arquivo ainda não tenha sido associado a uma unidadeatravés do comando OPEN, o resultado é ÙNDEFINED`;

9) ERR indica que, caso ocorra um erro, o fluxo de execução do programa será desviadopara o comando identificado por <rótulo>;

10) EXIST retorna um valor lógico informado se o arquivo existe (.TRUE.) ou não(.FALSE.);

11) FORM retona uma string informando se o arquivo foi aberto para operações formatadas(`FORMATTED`) ou não formatadas (ÙNFORMATTED`); caso o arquivo ainda nãotenha sido associado a uma unidade através do comando OPEN, o resultado éÙNDEFINED`;

12) FORMATTED retorna uma string informando se o arquivo pode ser aberto paraoperações formatadas (`YES`) ou não (`NO`);caso o processador não possa determinaressa possibilidade, o resultado é ÙNKNOWN`;

13) Ao usar o atributo IOSTAT, o resultado do OPEN será armazenado na variável inteira<resultado>; o valor 0 indica que não ocorreu erro, ou fim do arquivo ou fim do registro,e qualquer outro valor é o número identificador de um erro, dependente daimplementação;

14) NAME retorna uma string contendo o nome do arquivo associado a uma <unidade>,caso UNIT= <unidade> tenha sido especificado, se FILE= <nome-arquivo> foiespecificado, então retorna <nome-arquivo>; caso o arquivo não tenha sido conectado auma unidade através de um comando OPEN, ou não tenha nome, o resultado é definido;

15) NAMED retorna uma variável lógica especificando se o arquivo tem um nome (.TRUE.)ou não (.FALSE.);

16) NEXTREC retorna uma variável inteira indicando qual o número do próximo registronum arquivo aberto para acesso direto (o primeiro é indicado pelo número 1);

17) NUMEBR retorna uma variável inteira indicando qual a unidade associada ao arquivo;não pode ser usada em conjunto com UNIT = <unidade>;


18) OPENED retorna uma variável lógica indicando se o arquivo indicado por FILE=<nome-arquivo > ou UNIT= <unidade> está aberto (.TRUE.) ou não (.FALSE.);

19) PAD retorna uma string contendo `YES` se o arquivo foi aberto com PAD = `YES`, ou`NO` caso contrário;

20) POSITION retorna uma string contendo ASIS se a posição de um arquivo já associado auma unidade não é alterada, enquanto arquivos novos sempre estão posicionados noinicio; REWIND se o arquivo foi reposicionado para o seu inicio; APPEND se o arquivofoi reposicionado para o seu fim, permitindo, por exemplo, que novos registros sejamadicionados ao arquivo,; e UNDEFINED se o arquivo ainda não foi aberto ou se foiaberto para acesso direto;

21) READ retorna uma string contendo `YES` se o arquivo foi aberto para leitura, `NO` se oarquivo não pode ser lido e ÙNKNOWN` se o processador não pode determinar essacondição;

22) READWRITE retorna uma string contendo `YES` se o arquivo foi aberto para leitura eescrita, `NO` se o arquivo não pode ser lido e ÙNKNOWN` se o processador não podedeterminar essa condição;

23) RECL retorna uma variável inteira o tamanho de um registro, em bytes, para um arquivode acesso direto, ou o tamanho do maior registro de um arquivo de acesso seqüencial;

24) SEQ retorna uma string contendo `YES` se o arquivo foi aberto para acesso seqüencial,`NO` se não e ÙNKNOWN` se o processador não pode determinar essa condição;

25) UNFORMATTED retorna uma string contendo `YES` se o arquivo foi aberto paraoperações formatadas, `NO` se não e ÙNKNOWN` se o processador não poderdeterminar essa condição;

26) WRITE retorna uma string contendo `YES` se o arquivo foi aberto para escrita, `NO` seo arquivo não pode ser lido e ÙNKNOWN` se o processador não pode determinar essacondição;

Exemplo 8.4 Comandos CLOSE, INQUIRE e OPEN.

PROGRAM TESTE

LOGICAL :: EXISTECHARACTER*9 :: NONE = `dados.dat`

INQUIRE(FILE=NOME,EXIT=EXISTE)

IF (EXISTE) THENOPEN (UNIT=1, FILE=NOME, STAUTS=ÒLD`)CLOSE(1,STATUS=`DELETE`)

END IF

END PROGRAM TESTE

O programa faz uma consulta para verificar se o arquivo dados.dat existe. Se a variável

EXISTE contiver um valor .TRUE. após a execução do comando INQUIRE, então o arquivo será

aberto com o atributo STATUS= ÒLD`, indicando que ele já existe. Após, o comando CLOSE será

executado com o atributo STATUS= `DELETE`, efetivamente removendo o arquivo. Observe as

duas maneiras de especificar a unidade 1, nos comandos OPEN e CLOSE.


8.1.6 Comando Format e Especificações de Formato

FORMAT é o comando que contém uma lista de especificações de formato que permite ao

programador ter controle sobre os dados de entrada e saída.

Exemplo 8.5 do uso de um comando de formatação:

PRINT 10, N, X, Y

10 FORMAT (I3, F8.3, F5.1)

sendo que:

PRINT e FORMAT são comandos (ou palavras-chave);

"10" é número de comando;

"N,X,Y" é lista de saída;

"I3,F8.3,F5.1" são especificações de formato.

9. SUBPROGRAMAS

Um subprograma tem um conjunto opcional de argumentos, os quais podem ser de entrada,

de saída ou de entrada e saída. Um argumento é um nome que só pode ser referenciado dentro do

subprograma. Cabe observar que nada impede que existam, em outras seções do programa,

variáveis com o mesmo nome de argumentos de subprogramas; deve-se ressaltar, no entanto, que

essas variáveis não são os argumentos. A associação entre um argumento e seu valor só é dada

quando o subprograma é invocado.

Um subprograma pode ser interno ou externo. No primeiro caso, um subprograma só pode

ser invocado no bloco dentro do qual ele foi definido, após o comando CONTAINS; no segundo,

um subprograma pode existir com um código separado do programa principal e de outros

subprogramas, ou dentro de um MODULE.

A execução de um subprograma é feita até que se encontre o comando END SUBROUTINE

ou END FUNCTION, ou quando o comando RETURN seja executado. Quando um subprograma

termina sua execução, o fluxo de execução do programa retorna para o comando imediatamente

posterior ao comando de invocação do subprograma.


9.1 Subrotinas

Uma subrotina em FORTRAN 90 é declarada de acordo com a seguinte sintaxe:

[RECURSIVE] SUBROUTINE <nome-subrotina> [ ( <lista-argumentos> ) ]

[ <declarações-argumentos> ]

[ <declarações-internas> ]

[ <comandos> ]

END SUBROUTINE <nome-subrotina>

<lista-argumento> :: = <argumento-1> [,

<argumento-2> [ ... [, <argumento-n> ] ] ]

Semântica:

1) RECURSIVE é um atributo opcional da subrotina e indica que ela é recursiva, isto

é, pode existir uma invocação de <nome-subrotina> dentro dos <comandos>,

inclusive de forma encadeada;

2) <argumento-1> a <argumento-n> são listas de argumentos, opcionais, cada

argumento separado por vírgula;

3) <declarações-argumento> é a declaração dos tipos de cada argumento, os quais

podem ter o atributo INTENT;

4) <declarações-internas> é a declaração das variáveis que existem apenas no escopo

da subrotina;

5) <comandos> é uma seqüência de comandos da linguagem, os quais serão

executados quando da inovação de <nome-subrotina>; se um desses comandos for

o comando RETURN, a execução da subrotina é encerrada.


Exemplo 9.1 Passagem de argumentos a uma subrotina.

PROGRAM TESTEINPLICIT NONEINTEGER, PARAMETER :: I = -4, F = 7, N = F + I + 1INTEGER, DIMENSION(I,F) :: AINTEGER :: JCALL SUB(A)PRINT *, “CHAMADA COM :”WRITE(*,`(4(“ A(“,I2,”)=”,I4))`) (J,A(J),J=I,F)

CALL SUB1(N,A)PRINT *, “CHAMADA COM :”WRITE(*,`(4(“ A(“,I2,”)=”,I4))`) (J,A(J),J=I,F)

CONTAINSSUBROUTINE SUB(ARR)IMPLICIT NONEINTEGER, DIMENSION(:) :: ARRINTEGER :: N, I

N = SIZE(ARR)DO I = 1, N

ARR(I) = 1END DO

END SUBROUTINE SUB

SUBROUTINE SUB1(N,ARR)IMPLICIT NONEINTEGER, DIMENSION (*) :: ARRINTEGER, INTENT()IN :: NINTEGER :: I

DO I = 1, NARR(I) = 1

END DOEND SUBROUTINE SUB1

END PROGRAM TESTE

Nesse exemplo, mostramos como se pode transmitir um arranjo com uma dimensão a uma

subrotina, de duas formas. Ao se executar a chamada CALL SUB(A), dentro da subrotina SUB será

submetido que o argumento ARR tem a mesma shape do arranjo A (mas não terá o mesmo rank),

através da declaração INTEGER, DIMENSION(:) :: ARR. O comando N = SIZE(ARR) armazena

em N o numero de elementos de ARR (nesse caso, N terá o valor 12). Dentro da subrotina, os

elementos do arranjo ARR são acessados pelos índices 1, 2, ..., 11 ~ e não pelos índices -4, -3, -2,

..., 7 com os quais os elementos de A são acessados dentro do programa principal.

Já a rotina SUB1 declara o argumento ARR na forma INTEGER, DIMENSION(*) :: ARR.

Da mesma forma que na rotina SUB, não haverá mais correspondência entre o rank de A e o de

ARR. Porem, o uso dessa forma de declaração impede que se use o intrínseco SIZE(ARR) e,


portanto, necessário que o programador passe a subrotina o tamanho do arranjo A com um outro

argumento, N, de forma a poder acessar todos os elementos do arranjo.

Em ambos os casos, quando do retorno ao programa principal, verifica-se que os elementos

de A contêm os valores 1, 2, 3, ..., 12, armazenados nos elementos -4, -3, ..., 7, como demonstra a

saída do programa:

CHAMADA COM :

A(-4) = 1 A(-3) = 2 A(-2) = 3 A(-1) = 4

A(0) = 5 A(1) = 6 A(2) = 7 A(3) = 8

A(4) = 9 A(5) = 10 A(6) = 11 A(7) = 12

CHAMADA COM :

A(-4) = 1 A(-3) = 2 A(-2) = 3 A(-1) = 4

A(0) = 5 A(1) = 6 A(2) = 7 A(3) = 8

A(4) = 9 A(5) = 10 A(6) = 11 A(7) = 12

9.2 Módulos

U módulo é uma das possíveis seções de códigos de um programa FORTRAN 90. O uso dos

módulos permite uma melhor estruturação e controle de bibliotecas de subprogramas na linguagem.

Dentro de um modulo, podem-se declarar estruturas de dados, variáveis, subrotinas e

funções; porém, não pode haver qualquer comando executável dentro de um modulo.

Exemplo 9.2 Definição de um módulo, com seção declarativa de variáveis e subprogramas.

MODULE VETOR_3D_MODULOTYPE VETOR_3D

REAL :: X, Y, ZEND TYPE VETOR_3D

CONTAINSSUBROUTINE ATRIBUI_VETOR(A,B)TYPE (VETOR_3D), INTENT(OUT) :: AREAL, DIMENSION(3), INTENT(IN) :: B

A%X = B(1)A%Y = B(2)A%Z = B(3)

END SUBROUTINE ATRIBUI_VETOR

TYPE (VETOR_3D) FUNCTION ADICAO_VETORIAL &(A,B) RESULT (C)

TYPE (VETOR_3D), INTENT(IN) :: A,B


C%X = A%X + B%XC%Y = A%X + B%YC%Z = A%X + B%Z

END FUNCTION ADICAO_VETORIAL

TYPE (VETOR_3D) FUNCTION SUBTRACAO_VETORIAL &(A,B) RESULT (C)

TYPE (VETOR_3D), INTENT(IN) :: A,BC%X = A%X - B%XC%Y = A%X - B%YC%Z = A%X - B%Z

END FUNCTION SUBTRACAO_VETORIAL

TYPE (VETOR_3D) FUNCTION INVERT_VETOR(A) &RESULT (B)

TYPE (VETOR_3D), INTENT(IN) :: AB%X = -A%XB%Y = -A%XB%Z = -A%X

END FUNCTION INVERT_VETOR

REAL FUNCTION PRODUTO_ESCALAR(A,B) RESULT &(ALPHA)

TYPE (VETOR_3D), INTENT(IN) :: A, BALPHA = A%X*B%X+A%Y*A%Y+A%Z*B%Z

END FUNCTION PRODUTO_ESCALAR

TYPE (VETOR_3D) FUNCTION PRODUTO_VETORIAL &(A,B) RESULT (C)

TYPE (VETOR_3D), INTENT(IN) :: A,BC%X = A%Y - B%Z - A%Z*B%YC%Y = A%Z - B%X - A%X*B%ZC%Z = A%X - B%Y - A%Y*B%X

END FUNCTION PRODUTO_VETORIAL

END MODULE VETOR_3D_MODULO

O modulo VETOR_3D define um tipo derivado VETOR_3D, o qual pode ser utilizado

dentro do módulo e, também, por um programa principal, subprograma e módulo que se refiram a

esse módulo através do comando USE VETOR_3D_MODULO.

O comando USE permite que se faça referencia a tipos de dados, dados (que não tenham

sido declarados com o atributo PRIVATE ) e subprogramas definidos em um módulo. Sua sintaxe é

a seguinte:


USE <nome-módulo> [, <lista-nomes-locais> | ONLY :: [ <seleção> ] ]

<lista-nomes-locais> ::= <nome-local> => <nome-no-módulo> [,[ ... [, <nome-local> =><nome-no-módulo> ] ] ]

<seleção> :: = <lista-nomes-módulo> | <lista-nomes-locais> | OPERATOR(<operador>) | ASSIGNMENT(=)

<lista-nomes-no-módulo> ::= <nome-no-módulo> [, [ ... [, <nome-no-módulo> ] ] ]

Semântica:

<nome-módulo> é o nome de um módulo, declarado num comando MODULE...ENDMODULE;

Se for utilizada a palavra-chave ONLY, então dentro da seção de código onde o comandoUSE foi usado só poderá fazer referencia a subprogramas declarados em <nome-módulo> cujos nomes estejam listados em <seleção>;

<lista-nomes-locais> é uma lista contendo os nomes locais pelos quais subprogramasdeclarados num módulo serão acessados;

<lista-nomes-no-módulo> é uma lista contendo os nomes de subprogramas declaradosnum módulo.

Exemplo 9.3 Utilização de um módulo dentro de um programa.

PROGRAM TESTE_VETOR_3DUSE VETOR_3D_MODULO, ONLY : VETOR_3D, ATRIBUI_VETOR, &

ESCALAR => PRODUTO_ESCALAR, &PRODUTO_VETORIAL, &ADICAO_VETORIAL

IMPLICIT NONETYPE (VETOR_3D) :: U, V, WREAL :: ALPHA, BETAINTERFACE OPERATOR (+)

MODULE PROCEDURE ADICAO_VETORIALEND INTERFACEINTERFACE OPERATOR (.o.)

MODULE PROCEDURE ESCALAREND INTERFACEINTERFACE OPERATOR (.x.)

MODULE PROCEDURE PRODUTO_VETORIALEND INTERFACEINTERFACE ASSIGNMENT (=)

MODULE PROCEDURE ATRIBUI_VETOREND INTERFACE

U = (/ 1.0, 1.0, 1.0 /)U = (/ 0.0, -1.0, 1.0 /)ALPHA = ESCALAR (U,V) !ALPHA = 0.0


BETA = U .o. V !BETA = 0.0W = U .x. (U+V) !W = (/ 2.0, -1.0, -1.0 /)

END PROGRAM TESTE_VETOR_3D

O programa TESTE_VETOR_3D pode faze uso das definições de tipo e de subprogramas

no módulo VETOR_3D_MODULO através do comando USE VETOR_3D_MODULO. A lista após

a palavra-chave ONLY informa que, daquele módulo, apenas a definição de tipo VETOR_3D e os

subprogramas ATRIBUI_VETOR, ADICAO_VETORIAL, PRODUTO_ESCALAR e

PRODUTO_VETORIAL poderão ser utilizados dentro do programa TESTE_VETOR_3D; além

disso, o subprograma PRODUTO_ESCALAR só pode ser invocado através do nome local

ESCALAR. Quaisquer outras referencias a subprogramas presentes no módulo

VETOR_3D_MODULO incorrerão em erro de composição.

São definidos, também, quatro operadores: um deles é uma sobrecarga do operador +, que

efetuará a operação de soma vetorial, componente a componente; um corresponde à atribuição de

valores a um vetor, expressos como um arranjo unidimensional de três elementos; e os outros dois

são novos operadores, definidos como .o. e .x., correspondendo aos produtos escalar e vetorial.

Note que, como foi definido um nome local para o subprograma PRODUTO_ESCALAR, então o

seu nome local é que deve ser utilizado na definição do operador .o. Além disso, observe que, pode-

se fazer referencias a subprogramas associados a operadores da forma usual, como no comando

ALPHA = ESCALAR(U,V).


REFERÊNCIAS BIBLIOGRÁFICAS

ADAMS, J. et. Al. Fortran 90 Handbook. New York: McGraw-Hill, 1992.

CHIVERS, I. SLEIGHTHOLME, J. Introducing Fortran 95. London: Springer-Verlag, 2000.

CUNHA, R. D. Introdução à Linguagem de Programação: Fortran 90. Editora UFRGS 1 Edição,

2005. [http://www.livraria.ufrgs.br/ExibeProduto.aspx?codproduto=325]

GEHRKE, W. Fortran 90 Language Guide. London: Springer-Verlag, 1995.

ISO/IEC JTC1/SC22/WG5. Fortran 2003 Working Draft J3/03-007R1. Disponível em: <ftp://ftp.j3-

fortran.org/j3/doc/standing/007.>

KERRIGAN, J. Migrating to Fortran 90. Sebastopol: O`Reilly, 1993.


1. ANEXO A: FUNÇÕES INTRÍNSECAS

1. Funções Trigonométricas

Nome Definição Parâmetro Resultado

SIN(X) Seno (radianos). Se x forcomplexo, a parte real éassumida como um valor emradianos.

Real ou complexo real*4

SIND(X) Seno (graus) se x for complexo,a parte real é assumida como umvalor em graus


CSIN(X) seno(radianos) complex*4 complex*4

CDSIN(X) seno(radianos) complex*8 complex*8

DSIN(X) seno(radianos) real*8 real*8

DSIND(X) seno(graus) Real*8 real*8

ASIN(X) Arcoseno(radianos). Retornavalores na faixa [ -_2/,_/2 ]

Real, |x| .le. 1 real*4

ASIND(X) Arcoseno(graus). Retornavalores na faixa [-90,90]

real*8 real*8

DASIN(X) Arcoseno(radianos). Retornavalores na faixa [ -_2/,_/2 ]

real*8 real*8

DASIND(X) Arcoseno(graus). Retornavalores na faixa [-90,90]


COS(X) Coseno (radianos). Se x forcomplexo, a parte real éassumida como um valor emradianos.


COSD(X) Coseno (graus) se x forcomplexo, a parte real éassumida como um valor emgraus

Complex*4 complex*4

CCOS(X) coseno(radianos) Complex*4 complex*4

CDCOS(X) coseno(radianos) Complex*8 complex*8

DCOS(X) coseno(radianos) real*8 real*8

DCOSD(X) coseno(graus) Real*8 real*8

AÇOS(X) Arcocoseno(radianos). Retornavalores na faixa [ 0,_ ]


ACOSD(X) Arcocoseno(graus). Retornavalores na faixa [0,180]


DACOS(X) Arcocoseno(radianos). Retornavalores na faixa [ 0,_ ]

Real*8, |x| .le. 1 real*8

DACOSD(X) Arcocoseno(graus). Retornavalores na faixa [0,180]

Real*8, |x| .le. 1 real*8


TAN(X) Tangente (radianos) real real*4

TAND(X) Tangente (graus) real real*4

DTAN(X) Tangente (radianos) Real*8 real*8

DTAND(X) Tangente (graus) Real*8 real*8

COTAN(X) Cotangente (radianos) Real. X não pode ser0.

real*4

DCOTAN(X) Cotangente (radianos) Real*8. X não podeser 0.

real*8


ATAN(X) Arcotangente (radianos) Retornavalores na faixa [ -_2/,_/2 ]

Real Real*4

ATAND(X) Arcotangente(graus). Retornavalores na faixa [-90,90]

Real Real*4

DATAN(X) Arcotangente (radianos) Retornavalores na faixa [ -_2/,_/2]

Real*8 Real*8

DATAND(X) Arcotangente(graus). Retornavalores na faixa [-90,90]

Real*8 Real*8

ATAN2(X,Y) Arcotangente(y/x) em radianos.Retorna valores na faixa [-_,_]

Real. x e y nãopodem ambos ser 0

Real*4

ATAN2D(X,Y) Arcotangente(y/x) em grasu.Retorna valores na faixa [-180,180]

Real. x e y nãopodem ambos ser 0

Real*4

DATAN2(X,Y) Arcotangente(y/x) em radianos.Retorna valores na faixa [-_,_]

Real*8. x e y nãopodem ambos ser 0

Real*8

DATAN2D(X,Y) Arcotangente(y/x) em grasu.Retorna valores na faixa [-180,180]

Real*8. x e y nãopodem ambos ser 0

Real*8

SINH(X) Seno hiperbólico (radianos) Real Real*4

DSINH(X) Seno hiperbólico (radianos) Real*8 Real*8

COSH(X) Coseno hiperbólico (radianos) Real Real*4

DCOSH(X) Coseno hiperbólico (radianos) Real*8 Real*8

TANH(X) Tangente hiperbólico (radianos) Real Real*4

DTANH(X) Tangente hiperbólico (radianos) Real*8 Real*8


2. Funções Genéricas


DPROD(A,B) a*b Real*4,real*4 Real*8

EOF(UNIT) Verificar o final da unidade unit Integer*2 Logical

SIGN(X,Y) Retorna x com o sinal de y Real ou inteiro Real ou inteiro

ISIGN(X,Y) Retorna x com o sinal de y Inteiro inteiro

DSIGN(X,Y) Retorna x com o sinal de y real*8 real*8

3. Exponenciais

O número 'e' elevado a X (ex)

Nome Parâmetro Resultado

CDEXP(X) complex*16 complex*16

CEXP(X) complex*8 complex*8

DEXP(X) real*8 real*8

EXP(X) Real,inteiro ou complexo Mesmo que o parâmetro

4. Logaritmo


LOG(X) Logaritimo natural Real ou complexo Mesmo que oparâmetro

ALOG(X) Logaritimo natural real*4 real*4

DLOG(X) Logaritimo natural real*8 real*8

CLOG(X) Logaritimo natural complex*8 complex*8

CDLOG(X) Logaritimo natural complex*16 complex*16

LOG10(X) Logaritimo na base 10 real Mesmo que oparâmetro

ALOG10(X) Logaritimo na base 10 real*4 real*4

DLOG10(X) Logaritimo na base 10 real*8 real*8


5. Máximos


MAX(X1,X2,...) Maior valor Qualquer tipo Maior tipo entre osvalores

MAX0(X1,X2,...) Maior valor inteiro inteiro

AMAX1(X1,X2,...) Maior valor real real

AMAX0(X1,X2,...) Maior valor inteiro real

MAX1(X1,X2,...) Maior valor real inteiro

DMAX1(X1,X2,...) Maior valor real*8 real*8

6. Mínimos

Semelhante as funções de máximo (MIN, MIN0, AMIN1, AMIN0, MIN1, DMIN1).

Resto da Divisão de X por Y.


MOD(X,Y) Real ou inteiro Real ou onteiro

AMOD(X,Y) real*4 real*4

DMOD(X,Y) real*8 real*8

8. Raiz Quadrada de X


SQRT(X) Real ou complexo Real ou complexo

DSQRT(X) real*8 real*8

CSQRT() complex*8 complex*8

CDSQRT(X) Complex*16 complex*16

9. Truncamento de X


AINT(X) real real

DINT(X) real*8 real*8


10. Arredondamento de X

Nome Parâmetro Resultados

NINT(X) real Inteiro

DNIT(X) Real*8 Real*8

ANINT(X) real real

IDNINT Real*8 inteiro

11. Diferença Positiva Entre X e Y( se Y > X o valor é zero)Nome Parâmetro Resultado

DIM(X,Y) Real ou Inteiro Real ou Inteiro

DDIM(X,Y) real*8 real*8

DIM(X,Y) Inteiro inteiro

12. Tipo de Dado


ALLOCATED(X) .true. Se a for vetor oumatriz

Todos lógico

EPSILON(X) Menor valor que pode serincrementado

Real real

HUGE(X) Maior valor possível Real ou inteiro Real ou inteiro

MAXEXPONENT(X) Maior expoente possível Rel real

MINEXPONENT(X) Menor expoente possível Real real

NEAREST(X,Y) Se y é positivo retorna omaior real se negativo omenor real

Real real

PRECISION(X) Número de casas decimais Real real

TINY(X) Menor valor positivo quepode ser armazenado

Real real


13. Transformação do Tipo de X


INT(X) Real, inteiro ou complexo inteiro

INT1(X),INT2(X),INT4(X),INTC(X)

Real, inteiro ou complexo Integer*1,integer*2,integer*4,einteger

IFIX(X) Real*4 inteiro

HFIX(X) Real, inteiro ou complexo integer*2

JFIX(X) Real, inteiro ou complexo integer*4

IDINT(X) Real*8 inteiro

REAL()X Real, inteiro oucomplexoREAL*4

DREAL(X) Complex*16 Real*4

FLOAT(X) Inteiro real*4

SNGL(X) Real*8 real*4

DBLE(X) Real*8 ou complexo real*8

DFLOAT(X) Real*8 ou complexo complexo

CMPLX(x) Inteiro, real ou complexo complexo

DCMPLX(X) Inteiro, real ou complexo complex*16

ICHAR(X) ASCII inteiro

CHAR(X) Integer*4 ASCII

14.Complexos


IMAG(X) Retorna a parteimaginária

Complexo Real

DIMAG(X) Retorna a parteimaginária

Complex*16 Real*8

AIMAG(X) Retorna a parteimaginária

Complex*8 Real*4

CONJG(X) Retona o complexoconjulgado

complex*8 Complex*8

DCONJG(X) Retorna o complexoconjulgado

Complex*16 complex*16


15. Caracteres


LEN(X) Tamanho de x Character inteiro

LGE(X,Y) Compara x e y se x >=y .true.

Character logical

LGT(X,Y) Compara x e y se x > y.true.

Character logical

LLE(X,Y) Compara x e y se x <=y .true.

Character logical

LLT(X,Y) Compara x e y se x < y.true.

Character Logical

INDEX(X,Y) Procura y em x eretorna a posição

Character Inteiro

LEN_TRIM(X) Tamanho de menos onúmero de espaço

Character Inteiro

SCAN(X,Y) Procura um doscaracteres de y em x eretorna o número deocorrência

Character inteiro

VERIFY(X,Y) Procura um doscaracteres de y em x eretorna a posição daprimeira não ocorrência

Character inteiro

16. Valores Absolutos de X


ABS(X) Complexo ou real Complexo ou real

IABS(X) Inteiro Inteiro

DABS(x) Real*8 Real*

CABS(X) Complex*16 Complex*16

CDABS(X) Complex*16 real*8

Os valores absolutos dos dados complexos são calculados pela seguinte

formula:

apostila fortran curso inpe 2008 -...

Documents