apostila fortran curso inpe 2008 -...
TRANSCRIPT
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)
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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;
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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);
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
• 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:
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
• 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:
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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).
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
END PROGRAM PRINCIPAL
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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>
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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;
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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>.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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:
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
END PROGRAM PRINCIPAL
O programa, ao ser executado, produziria o seguinte resultado:
& 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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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=`,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)
END PROGRAM PRINCIPAL
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.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= `APOSTROPHE` | `QUOTE` | `NONE` ]
[ , ERR= <RÓTULO> ]
[ , FILE= `FORMATTED` | `UNFORMATTED` ]
[ , IOSTAT= <resultado> ]
[ , PAD= `YES` | `NO` ]
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
[ , POSITION= `ASIS` | `REWIND` | `APPEND` ]
[ , RECL= <tamanho-registro> ]
[ , STAUTS= `OLD` | `NEW` | `SCRATCH` | `REPLACE`]
[ , `UNKNOWN` ] )
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=
`APOSTROPHE` 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 = `UNFORMATTED`;
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;
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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> ]
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
[, 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 é `UNDEFINED`;
5) ACTION retorna uma string informando se o arquivo foi aberto para leitura(`ACTION`), 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 é`UNDEFINED`;
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 é `UNDEFINED`;
7) DELIM retorna uma string informando quais delimitadores são usados: nenhum(`NONE`), apostrofo (`APOSTROPHE`) ou aspas (`QUOTE`); caso o arquivo ainda nãotenha sido associado a uma unidade através do comando OPEN, o resultado é`UNDEFINED`;
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 é `UNDEFINED`;
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 (`UNFORMATTED`); caso o arquivo ainda nãotenha sido associado a uma unidade através do comando OPEN, o resultado é`UNDEFINED`;
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 é `UNKNOWN`;
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>;
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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 `UNKNOWN` 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 `UNKNOWN` 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 `UNKNOWN` 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 `UNKNOWN` 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 `UNKNOWN` 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=`OLD`)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= `OLD`, 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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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,
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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:
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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).
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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.
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Real ou complexo real*4
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]
Real ou complexo real*4
COS(X) Coseno (radianos). Se x forcomplexo, a parte real éassumida como um valor emradianos.
Real ou complexo real*4
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,_ ]
Real, |x| .le. 1 real*4
ACOSD(X) Arcocoseno(graus). Retornavalores na faixa [0,180]
Real, |x| .le. 1 real*4
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Nome Definição Parâmetro Resultado
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
2. Funções Genéricas
Nome Definição Parâmetro Resultado
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
Nome Definição Parâmetro Resultado
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
5. Máximos
Nome Definição Parâmetro Resultado
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.
Nome Parâmetro Resultado
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
Nome Parâmetro Resultado
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
Nome Parâmetro Resultado
AINT(X) real real
DINT(X) real*8 real*8
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
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
Nome Definição Parâmetro Resultado
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
13. Transformação do Tipo de X
Nome Parâmetro Resultado
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
Nome Definição Parâmetro Resultado
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
Cristiano Prestrelo de Oliveira – CPTEC/INPE_ (Introdução à Linguagem de Programação Fortran 90)
15. Caracteres
Nome Definição Parâmetro Resultado
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
Nome Parâmetro Resultado
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: