Sebenta

Escola Superior de
Tecnologia e de Gestão
INSTITUTO POLITÉCNICO DE BRAGANÇA
ALGORITMIA E PROGRAMAÇÃO
Textos de Apoio
Engenharia Mecânica
Engenharia Química
Luís Alves
Paulo Matos
Ano Lectivo de 2002/2003

APRESENTAÇÃO
Apresentação
Objectivos
Fornecer aos alunos conhecimentos necessários ao desenvolvimento

de uma descrição algorítmica.
Conceitos básicos e de nível intermédio sobre programação em
FORTRAN 77/90.
Desenvolvimento e implementação de soluções sobre casos típicos
de problemas de Engenharia e de Matemática.
Sistema de avaliação para 2002/2003
Avaliação Época Normal (1ª e 2ª Chamadas) e de Recurso

Prova escrita 80%
Fichas de avaliação 20%
As fichas de avaliação serão realizadas durante as aulas teóricas e práticas,

sem aviso prévio aos alunos. Os alunos terão de optar entre a nota final obtida pelas
fichas de avaliação e a realização de um exercício na prova prática de grau de
dificuldade superior.
Avaliação para a Época Especial

Prova escrita 100%
Fórmula de cálculo da nota final com fichas de avaliação

NotaFinal = 0.2 × FichaAvaliação + 0.8 × ProvaEscrita
Fórmula de cálculo da nota final sem fichas de avaliação

NotaFinal = 1 × ProvaEscrita
Algoritmia e Programação 2
APRESENTAÇÃO
Programa da disciplina
INTRODUÇÃO À RESOLUÇÃO ALGORÍTMICA DE PROBLEMAS

Noção de Algoritmo
Elementos básicos de uma descrição
Representação algorítmica
Representação das estruturas de dados
Diagramas das estruturas de dados
Diagramas de fluxo
Problemas sequenciais
Problemas com situações condicionadas
Problemas com situações cíclicas
Decomposição da solução
Do algoritmo ao programa, boas e más técnicas de programação
INTRODUÇÃO À PROGRAMAÇÃO
Processo de desenvolvimento de programas
Editor Vs Compilador
Compilador Vs Linker Vs Interpretador
Programa Vs Bibliotecas
FORTRAN 77 Vs FORTRAN 90
Compiladores/Interpretadores de FORTRAN
LINGUAGEM FORTRAN 77/90
Estrutura básica de um programa
Declaração de variáveis
Tipos simples de dados
Entrada e saída de dados
Expressões
Operadores aritméticos, relacionais e lógicos
APRESENTAÇÃO
Funções Intrínsecas
Estruturas de repetição
Formatação da entrada e saída de dados
Arrays
Estruturas de dados
Procedimentos e Funções
Funções de I/O
Bibliotecas externas
TÓPICOS AVANÇADOS DO FORTRAN
ESTUDO DE CASOS TÍPICOS
Bibliografia
S. Chapman, “Fortran 90/95 – For Scientists and Engineers”,
McGraw-Will.
L. Nyhoff, S. Leestma, “Fortran 90 – For Engineers and
Scientists”, Prentice-Hall.
W. Schick, G. Silverman, “Fortran 90 and Engineering
Computation”, Jonh Wiley & Sons.
I. M. Smith, “Programming in Fortran 90 – A first Course for
Engineers and Scientists”, Jonh Wiley & Sons.
T. M. R. Ellis, I. R. Philips, T. M. Lahey, “Fortran 90
Programming”, Addison-Wesley.
APRESENTAÇÃO
L. Alves, P. Matos, “Textos de Apoio de Algoritmia e
Programação”.
L. Alves, “Caderno de Exercícios de Algoritmia e Fortran”.
INTRODUÇÃO À RESOLUÇÃO ALGORÍTMICA DE
PROBLEMAS
Introdução à Algoritmia
Definição de Algoritmo
O algoritmo mais não é do que uma descrição de um conjunto de
operações que visam resolver um determinado problema. Descrição essa
que pode ser mais, ou menos, informal dependendo das exigências do
próprio problema e também de quem o implementa. Deve no entanto ser
suficientemente explicita para que não dê origem a interpretações distintas.
Um algoritmo é assim, um plano de acção que visa estabelecer um certo
efeito desejado ou, por outras palavras, obter uma solução para um
determinado tipo de problema.
Vantagens
Permite introduzir conceitos básicos sobre programação a quem nunca
os teve e, acima de tudo, permite disciplinar a forma de raciocinar a
quem não tem experiência de programação.
É uma forma de descrição suficientemente abstracta para que não se

depare com restrições próprias das linguagens de programação, nem
com detalhes de implementação.
Concepção de um programa
A concepção de um algoritmo, deve ser entendida como parte de todo

um processo, cujo objectivo final é resolver um determinado problema.
Por si só o algoritmo não tem grande utilidade, mas quando integrado
num processo suporta as fases posteriores.
Após a concepção do algoritmo há que avaliar tão exaustivamente

quanto possível, na tentativa de detectar qualquer falha de concepção.
Posteriormente vem a implementação que, dentro do contexto desta

disciplina, significa traduzir o algoritmo para uma linguagem de
programação.
O processo termina após se verificar que tudo funciona como

pretendido.
Concepção de um algoritmo
O processo começa por uma análise mais ou menos detalhada do

problema, de forma a apurar as componentes básicas da solução.
Posteriormente analisa-se cada uma dessas componentes, descrevendo

as operações a realizar para cada uma e sempre que necessário
decompondo essas operações em outras que permitam aumentar o
detalhe do algoritmo.
No nosso quotidiano deparamo-nos frequentemente com exemplos de

algoritmos, isto é, com situações em que nos são facultadas indicações de
como fazer algo:
instruções para uso de um electrodoméstico, receitas de culinária,
partituras musicais, etc.
(quando perguntamos, por exemplo, pelo caminho para os Correios, estamos
precisamente à espera que nos forneçam um algoritmo através do qual consigamos
chegar a esse destino)
Introduziremos então a noção de algoritmo de uma forma intuitiva,
usando como exemplos algoritmos que fazem descrições de acções do
nosso quotidiano.
Exemplos:
Confeccionar uma refeição
Caminhar até a um local determinado
Substituição de uma lâmpada
Exemplo: Substituição de uma lâmpada
Agora vejamos o algoritmo para a substituição de uma lâmpada sem

ainda nos preocuparmos com a formalidade da notação algorítmica.
Componentes básicas da solução

Garantir a segurança da operação
Arranjar e posicionar um meio de aceder à lâmpada
Remover a lâmpada
Colocar a nova lâmpada
Testar se a nova lâmpada funciona
Arrumar os meios despendidos na operação
De forma a tornar mais perceptíveis todas estas acções a quem não

conheça o processo de substituição de uma lâmpada, devemos usar um
maior nível de detalhe. Assim, temos o seguinte algoritmo:
Desligar a electricidade (no quadro geral – iluminação)
Pegar num banco
Colocar o banco por baixo da lâmpada
Subir para cima do banco
Remover a lâmpada
Pegar com uma mão no caixilho
Pegar com a outra mão na lâmpada
Rodar a lâmpada até desapertar
Descer do banco
Poisar a lâmpada velha
Pegar na nova lâmpada
Subir ao banco
Pegar com uma mão no caixilho
Inserir a lâmpada no caixilho
Rodar a lâmpada até esta ficar encaixada
Descer do banco
Ligar o quadro geral de electricidade
Acender o interruptor se este estiver desligado
Verificar se a lâmpada funciona
Deitar a lâmpada velha ao lixo
Pegar no banco e arrumá-lo
Solução Sequencial
Todas as acções (operações) têm de obedecer a uma certa ordem e só
começa a próxima quando as anteriores já tiverem terminado na sua
totalidade.
Remover a lâmpada
Solução com situações condicionais/repetição

Testar se a nova lâmpada funciona Testar se a nova lâmpada funciona
Descer do banco Descer do banco
Ligar o quadro geral de Ligar o quadro geral de
electricidade electricidade
Acender o interruptor se este Acender o interruptor se este
estiver desligado estiver desligado
Verificar se a lâmpada funciona Se a lâmpada funcionar
continuar, caso contrário voltar a
substituir.
Remover a lâmpada
Não
Testar se a nova
lâmapada funciona
Sim
Colocar a nova lâmpada Colocar a nova lâmpada

Descer do banco Descer do banco
Poisar a lâmpada velha Poisar a lâmpada velha
Pegar na nova lâmpada Pegar na nova lâmpada
Subir ao banco Subir ao banco
Pegar com uma mão no Pegar com uma mão no
caixilho caixilho
Inserir a lâmpada no caixilho Inserir a lâmpada no caixilho
Rodar a lâmpada até esta Enquanto a lâmpada não
ficar encaixada estiver encaixada, rodar
Vejamos agora outro algoritmo para resolução de equações de 2º

grau, ainda sem nos preocuparmos com a formalidade da notação
algorítmica.
Exemplo: Cálculo das raízes de uma equação de 2ª ordem
Uma primeira abordagem para a resolução do problema, pode ser

vista da seguinte forma:
Componentes básicas da solução

b ± b2 4 * a * c
Sabe-se que x1, x 2 =
2*a
Ler o valor de a, b e c
Calcular x1
Calcular x 2
Mostrar os resultados de x1 e x 2
No entanto, esta solução ainda é demasiado geral, pelo que devemos

detalhar o cálculo de x1 e x 2 . Assim,
b ± b2 4 * a * c
Sabe-se que x1, x 2 =
2*a
Ler o valor de a,b e c
Calcular x1
b + b2 4 * a * c
x1 =
2*a
Calcular x 2
b b2 4 * a * c
x2 =
2*a
Como sabemos, mediante o cálculo de b 2 4 * a * c podemos ter duas raízes

reais diferentes, iguais ou não ter raízes reais. Neste sentido, devemos
detalhar todas as situações possíveis:
b2 4*a*c > 0
b 2
4*a *c b 2
4*a*c = 0
b2 4*a*c < 0
Na primeira situação, existem duas raízes reais diferentes x1 e x 2 , na

segunda existem duas raízes reais iguais x1 = x 2 e na última não existem
raízes reais (apenas complexas).
Assim, uma possível solução final para o problema ficaria:
Ler o valor de a,b e c

Calcular b 2 4 * a * c
Se b 2 4 * a * c > 0 então
b + b2 4 * a * c
x1 =
2*a
b b2 4 * a * c
x2 =
2*a
Senão
Se b 2 4 * a * c = 0 então
b
x1, x 2 =
2*a
Mostrar x1
Senão
A equação não possui raízes reais
Fim do algoritmo
Diagrama de Fluxo
Símbolos
Estrutura sequencial de operações
Estrutura sequencial com operações de Entrada
Estrutura sequencial com operações de Saída
Início ou fim do algoritmo
Estrutura condicional, do tipo:

Se condição então
Lista Operações (caso verdadeiro)
Senão
Lista Operações (caso falso)
Ponto de convergência de mais do que uma

linha do fluxo de controlo
Ler o valor de a, b e c Início

Calcular b 2
4*a *c
Se b 2 4 * a * c > 0 então Ler

a,b,c
b + b2 4 * a * c
x1 =
2*a
b b2 4 * a * c delta = b2-4*a*c
x2 =
2*a
Senão delta > 0
falso
Se b 2 4 * a * c = 0 então verd.
b
x1, x 2 =
2*a x1 =
b + b2 4 * a * c
2*a
Mostrar x1 x2 =
b b2 4 * a * c
2*a
Senão
A equação não possui raízes reais
Mostrar
Fim do algoritmo x1 e x2
2
1 2
falso
delta = 0
verd.
x1,x2=-b/2*a
Mostrar
x1
Não há
raizes
Fim
Elementos de uma descrição

A seguir, veremos os elementos que constituem uma descrição
algorítmica com alguns exemplos para melhor os compreendermos.
Elemento: Exemplos:
Constantes 4, “Maria”, 3.14
Variáveis a, b, c, x1, x2, t
Operadores +, -, *, /, raiz
Expressões 4*a*c, x>y
Expressões de atribuição
(var = expressão) media = soma/n
Expressões condicionais
Se condição então SE nota >= 10 ENTÃO
... ESCREVER(“Aprovado”)
Senão fazer ... SENÃO
ESCREVER(“Reprovado”)
FIMSE
Expressões de repetição
Enquanto condição fazer
...
Para todos os elementos de um conjunto fazer
...
Para os valores de x entre vmin e vmax fazer
...
Decomposição do problema por módulos
Uma boa prática de programação consiste em subdividir o programa

em módulos (funções) que executam tarefas particulares do problema
global. Muitas destas funções estão já programadas pelo que, é suficiente a
sua invocação para as utilizar. No entanto, quando pretendemos tarefas

específicas, o que acontece a maior parte das vezes, então temos de
programar as funções.
Exemplo: Calcular a hipotenusa de um triângulo rectângulo h = a2 + b2
Ler os valores de a e b
Calcular a2 e b2 Como calcular uma potência?

Determinar o valor de x = a2 + b2
Calcular a raiz quadrada de x Como calcular uma raiz quadrada?
Início Início
Calcular a
Ler a e b potência de 2
de um dado
valor
t1=a2
t2=b2 Fim
x=t1+t2
h= x
Início
Mostrar
resultado
Calcular a raiz
quadrada de
Fim um dado valor
Fim
Estrutura formal da linguagem algorítmica

A linguagem algorítmica, como qualquer outra linguagem, deve
obedecer a regras. Portanto, existe uma sintaxe e uma semântica que tem de
ser rigorosamente seguidas.
Convenções estabelecidas para a descrição da sintaxe
MAIÚSCULAS e a negrito Palavras reservadas

[...] Partes opcionais da gramática
El Er Expressão do lado esquerdo (El)
deriva na frase do lado direito (Er)
“ ” Símbolos reservados dentro da
sintaxe
a|b Frase opcional entre a e b
Note-se que as convenções aqui estabelecidas servirão para

apresentar de uma forma mais abreviada a sintaxe da linguagem
algorítmica.
Estrutura de um algoritmo
algoritmo NOME “:” nome

[declaração variáveis]
[declaração de constantes]
INÍCIO
sequência de instruções
FIM.
declaração variáveis lista variáveis “:” tipo variável

[declaração variáveis]
tipo variável INTEIRO | REAL | ...
declaração de constantes lista atribuição constantes
lista atribuição constantes identificador “=” valor

[“,” lista atribuição constantes]
Exemplos: PI = 3.14 ou PI = 3.14, NotaMax = 20
NotaMax = 20
sequência de instruções instrução [sequência de instruções]
instrução instrução simples |

instrução SE |
instrução CASO|
instrução ENQUANTO |
instrução REPETIR |
instrução PARA
instrução simples ABORT [mensagem] |

atribuição |
invocação de procedimentos |
RETORNAR [expressão] |
“[“ descrição informal “]”
atribuição variável “ ” expressão
Estrutura de selecção simples
instrução SE SE condição ENTÃO

[SENÃO
v e rd . f a ls o
sequência de instruções]
FIMSE
Estrutura de selecção múltipla

Instrução CASO
CASO expressão IGUAL A
constante1 : sequência_de_instruções1
constante2, constante3 : sequência_de_instruções2
constante4 .. constante5 : sequência_de_instruções3
...
constanteN: sequência_de_instruçõesN
SENÃO sequênc_de_instr_alternativas
FIMCASO
express.
=cnst.1 =cnst.2 =cnst.3 =cnst.4 =cnst.N senão
=cnst.5
seq. seq. seq. seq. seq.

inst1 inst2 inst3 instN instAlt
instrução ENQUANTO ENQUANTO condição FAZER

falso FIMENQ
verd.
instrução REPETIR REPETIR

ATÉ condição
verd.
falso
Instrução PARA
PARA variável_controlo valor1 ATÉ valorN FAZER
FIMPARA
valor1<= falso
valorN
verd.
Exemplo: Analisa dois valores
Início
NOME : primeiro_algoritmo
a, b : inteiro a 1
b 2
INICIO
a 1
falso verd.
a>b
b 2
SE a > b ENTÃO
b 0 a 0
a 0
SENÃO
b 0
Fim
FIMSE
FIM.
Exercícios propostos
1) Ainda sem utilizar a linguagem algorítmica formal, detalhe o seguinte

algoritmo do nosso quotidiano:
Garantir a imobilidade do automóvel
Desapertar ligeiramente as porcas da roda a substituir
Elevar o carro
Retirar o pneu danificado
Colocar o pneu sobresselente
Apertar ligeiramente as porcas da roda
Baixar o automóvel
Acabar de apertar a roda
2) Agora, utilizando a linguagem algorítmica formal, desenvolva um

algoritmo que determine a média das notas de Algoritmia e
Programação.
Note que para resolver o segundo exercício, necessita de somar as notas

de todos os alunos de Algoritmia e Programação e só depois dividir este
resultado pelo número total de alunos.
Por outro lado, se pretendêssemos saber a lista dos alunos com nota
superior à média teríamos de usar arrays (estrutura de dados explicada
adiante).
CONCEITOS BÁSICOS DE PROGRAMAÇÃO
Conceitos básicos de programação
O desenvolvimento de software obedece a determinadas etapas bem

delineadas e que foram objecto de estudo de vários autores. A este conjunto de
etapas ou fases dá-se o nome de ciclo de vida do software. Apresentamos a
seguir as mais importantes.
Desenvolvimento de programas
Análise prévia do problema

Estruturação da solução (algoritmo e/ou diagrama de fluxo)
Codificação numa linguagem de programação adequada
Compilação ou interpretação
Linkagem
Teste da solução obtida
A seguir, apresentamos sob a forma esquemática o gráfico de fluxo do

processo, desde a criação do código fonte (“source code”) até à obtenção da
solução final isenta de erros.
Gráfico de fluxo do processo
Codificação Compilação não não

Executável
(Editar) & Erros? Erros? Fim
(a.out)
Linkagem
Sim Sim
Durante o desenvolvimento de um programa, vários são os tipos de erros

que podemos encontrar, quer na fase de compilação quer na fase de teste.
Detecção de erros na compilação e no teste
Compilação
Erros léxicos
Erros sintácticos
Erros semânticos
Teste
Erros de sistema
Erros lógicos
Registe-se que os erros lógicos são os que apresentam maior dificuldade na sua
detecção, pois permitem a execução do programa. O problema está em que o
programa não apresenta os resultados desejados.
Gráfico de fluxo do processo (vários módulos)
Codificação não
(Editar) Compilação Erros?
Sim
não
Executável
Erros? Fim
Linkagem
(a.out)
Codificação não
(Editar) Compilação Erros? Sim
Sim
Existem vários editores onde podemos escrever o código fonte do

programa. Para o nosso caso, nas aulas práticas vamos utilizar o editor “pico”
do sistema operativo Unix. Este é um editor de texto de simples utilização.
Exemplos de editores
Modo texto (ASCII)

Exemplos: pico, vi, notepad, etc.
Exemplos de compiladores/interpretadores
g77 - GNU (Fortran) 77

f90 (Interpretador de Fortran 90 para Fortran 77)
gcc, Visual C++, Visual Basic, etc
Existem no mercado várias ferramentas para compilar programas escritos

em linguagem de programação Fortran. Nas aulas práticas, vai ser utilizado o
interpretador “f90” que corre no sistema operativo Unix. Esta ferramenta lê os
programas em Fortran 90, converte-os para Fortran 77 e depois efectua a sua
compilação.
O comando que deverá ser usado para compilar os programas escritos
em Fortran 90 é o seguinte:
$ f90 -o nomeficheiroexecutável nomeficheirofonte.f90
onde nomeficheiroexecutável é o nome do ficheiro em código máquina obtido a
partir do ficheiro em código fonte com o nome nomeficheirofonte.f90. Por
exemplo, o seguinte comando:
$ f90 –o exe1 exe1.f90
cria o ficheiro executável com o nome exe1 a partir do ficheiro fonte de nome
exe1.f90.
Caso o comando de compilação seja o seguinte:
$ f90 -o nomeficheirofonte.f90
o interpretador f90 produzirá um ficheiro executável, portanto em código

máquina, com o nome a.out.
Note-se que a utilização do primeiro comando é preferível, pois é a única
forma de guardarmos em disco o ficheiro fonte e o correspondente ficheiro
executável.
Na programação, seja ela em que linguagem for, é comum recorrer-se a
bibliotecas. Normalmente, existem bibliotecas com funções (módulos) já
programadas, no entanto nós podemos construir as nossas próprias bibliotecas.
Programas + Bibliotecas
O gráfico de fluxo do processo, recorrendo a bibliotecas fica com o

seguinte aspecto:
Bibliotecas
Codificação Compilação não não

Executável
(Editar) & Erros? Erros? Fim
(a.out)
Linkagem
sim sim
O Fortran evoluiu desde o seu aparecimento. Assim a versão 77 do

Fortran foi alterada, dando origem à versão 90. Esta apresenta algumas
diferenças quer ao nível das instruções quer ao nível do formato do texto fonte
em relação à versão anterior, pelo que apresentamos a seguir as mais
importantes.
Fortran 77 vs. Fortran 90
Diferenças ao nível das instruções
Diferenças ao nível do formato do texto fonte

Fortran 77 – Fixed Source Form
Fortran 90 – Free Source Form
Fixed Source Form – Fortran 77
Texto dividido em colunas e linhas

As expressões estão compreendidas entre a coluna 7 e 72. Daí em diante
todo o texto é ignorado (73-80)
A coluna 6 preenchida com um qualquer caracter, diferente do espaço ou de
zero, assinala continuação da linha anterior
Uma expressão pode ocupar no máximo 19 linhas
O caracter “C” ou “*” na primeira coluna indica que esta é um comentário
Um ponto de exclamação (“!”) após a coluna 6 assinala a presença de um
comentário a partir desse ponto (trailing comment)
Admite várias expressões numa linha, desde que separadas por “;”
Nas primeiras 5 colunas é possível utilizar labels (etiquetas) para identificar
as instruções, (inteiro positivo [1,99999])
Qualquer espaço em branco dentro de uma expressão não é significativo
(excepto dentro de strings)
Fixed Source Form – Fortran 77 - Exemplo
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
P R O G R A M T E S T E
a , b : : I N T E G E R
c : : R E A L
1 0 1 0 R E A D * , a ; R E A D * , b
1 0 2 0 c = ( a + b ) / 2 . 0
C I s t o é u m c o m e n t á r i o
* I s t o t a m b é m é u m c o m e n t á r i o
P R I N T * , “ M É D I A É “
, c ! I s t o é o u t r o c o m e n t á r i o
Free Source Form – Fortran 90
Cada linha pode conter até 132 caracteres

Uma expressão pode ocupar mais do que uma linha e no máximo 39
O caracter “&” no fim de cada linha indica que esta continua na próxima
As strings podem ocupar mais do que uma linha, desde que se utilize o
caracter “&”, respectivamente, no fim e princípio das linhas
O ponto de exclamação (“!”) assinala o início de um comentário
Uma linha pode conter mais do que uma expressão, desde que estas se
encontrem separadas pelo caracter “;”
As labels devem ser colocadas antes das expressões e com pelo menos um
espaço de intervalo entre estas
Free Source Form – Fortran 90 - Exemplo
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
P R O G R A M T E S T E
a , b : : I N T E G E R
c : : R E A L
1 0 1 0 R E A D * , a ; R E A D * , b
1 0 2 0 c = ( a + b ) &
/ 2 . 0
! A m é d i a = ( a + b ) / 2
P R I N T * , “ MÉ D I A &
& É “ , c
E N D
FORTRAN
Fortran
Qualquer linguagem de programação utiliza um determinado conjunto de

caracteres, cada um dos quais com uma função específica. Assim, o Fortran
utiliza o seguinte conjunto de caracteres:
Caracteres
Maiúsculas [A - Z]
Minúsculas [a - z]
Dígitos [0 - 9]
Underscore _
Símbolos aritméticos + - * / **
Caracteres invisíveis espaço, tabulador e new line
Outros ().=,‘$:!“%&;<>?
Convenção estabelecida para a representação
MAIÚSCULAS e a negrito Palavras reservadas

Itálico Partes a preencher pelo programador
[ xxx ] Indicação de que xxx é opcional (pode ou
não surgir no programa)
Estrutura de um programa
PROGRAM nome_do_programa
Declaração_de_variáveis
Parte_executável_do_programa
END [PROGRAM [nome_do_programa]]
FORTRAN
Identificadores
Nomes que servem para representar variáveis, funções, sub-rotinas,

constantes, etc.
Regras para designar os identificadores:

Um identificador só pode ser composto por caracteres do abecedário,
quer sejam maiúsculos, ou minúsculos ([a-z;A-Z]), por dígitos
numéricos ({0,1,...,9}) e pelo caracter underscore ‘_’.
O Fortran não é case sensitive, isto é, não faz distinção entre caracteres
minúsculos e maiúsculos.
A primeira letra (e eventualmente única) de cada identificador tem que
ser sempre um caracter do abecedário.
Um identificador só pode conter até 31 caracteres e deve consistir numa
única palavra (formada por [a-z;A-Z], {0,1,...,9} e ‘_’).
Exemplos de Identificadores
Correctos
nota
numero_de_notas
Numero_de_Notas
N123
Errados
12_notas
12notas
_notas
FORTRAN
Palavras reservadas
As palavras (tokens) reservadas são todas aquelas que por fazerem parte
da própria linguagem, não podem ser utilizadas pelo programador para
representar qualquer outro tipo de elemento.
O Fortran standard não possui palavras reservadas, o que significa que
uma mesma palavra tanto pode representar uma instrução ou parte de
uma instrução, como uma variável, ou designação de um programa.
Desaconselha-se a utilização de identificadores com o mesmo nome de
uma das palavras reservadas.
Devido ao elevado número de funções intrínsecas que fazem parte do
Fortran, por vezes é difícil escolher um nome que já não seja utilizado.
Nem todos os compiladores são standard, pelo que há alguns que só e
simplesmente não permitem o uso de palavras reservadas como
identificadores.
Desvantagens:
Pode levar o compilador a interpretações erradas, ou pelo menos a não
executar o que se pretende;
Tornar o próprio programa ilegível para o programador.
Variável
As variáveis servem para armazenar dados que podem ser alterados ao

longo da execução do programa.
FORTRAN
Tipo de uma variável

A cada variável está associado, quer implicitamente, quer
explicitamente, um tipo que identifica o valor que esta pode conter, tal é de
extrema importância para a qualidade do código a gerar. Por exemplo o tipo
INTEGER permite indicar que uma variável pode armazenar valores inteiros.
Declaração de variáveis
Em Fortran as variáveis podem ser declaradas implicitamente ou
explicitamente.
Declaração Implícita
Quando a variável não é declarada de forma explícita, o tipo é
determinado da seguinte forma:
Se o primeiro caracter da variável estiver compreendido entre [i,n], então
a variável é do tipo inteiro.
Caso contrário a variável é do tipo real.
Declaração Explícita
Caso o programador o deseje (e é de todo aconselhável) pode declarar
explicitamente o tipo da variável, da seguinte forma;
Declaração Tipo_variável [,lista_modificadores] :: lista_variáveis
Exemplo: INTEGER :: a, b, c
A expressão IMPLICIT NONE no início do programa força a declaração

explícita das variáveis.
FORTRAN
Tipos intrínsecos ou primitivos
INTEGER - Variáveis do tipo inteiro positivo ou negativo. Ocupa 32 bits

e permite representar valores [-231,+231-1].
REAL - Variáveis do tipo vírgula flutuante (real), em que a vírgula é

representada pelo caracter ponto ‘.’. Ocupa 32 bits segundo
a seguinte estrutura:
1 bit de sinal 23 bits 1 bit de sinal 7 bits

mantissa mantissa expoente expoente
31 0
COMPLEX - Variáveis do tipo complexo (a + ib), em que ambas as

componentes são do tipo REAL.
DOUBLE PRECISION - Variáveis do tipo vírgula flutuante mas com

uma precisão superior ao REAL.
LOGICAL - Variáveis do tipo lógico que podem assumir um dos

seguintes valores: .FALSE. ou .TRUE..
CHARACTER - Variáveis do tipo caracter ou strings.
Variável
INTEGER :: val1, val_t ! Declaração de duas variáveis do tipo inteiro
FORTRAN
REAL :: f1,f2F ! Declaração de duas variáveis reais
DOUBLE PRECISION :: dp ! Declaração de uma variável do tipo real com o

! dobro da precisão
COMPLEX :: c_1, c_2 ! Declaração de duas variáveis do tipo

! complexo
CHARACTER :: c ! Declaração de uma variável do tipo caracter
Iniciação de variáveis
declaração Tipo_variável [,lista_modificadores] :: lista_variáveis
lista_variáveis nome_da_variável = expressão_constante [,lista_variáveis]
Exemplos:
INTEGER :: nalunos = 10, a, b
REAL :: PI = 3.1415
CHARACTER :: nome = “Luís”
Iniciação de constantes
declaração Tipo_constante, PARAMETER :: lista_constantes
lista_constantes nome_da_constante=expressão_constante[,lista_constantes]
FORTRAN
Exemplos:
INTEGER, PARAMETER :: nalunos = 10
REAL, PARAMETER :: PI = 3.1415
Entrada e Saída de dados
Entrada
READ *,lista_parâmetros_onde_guardar_os_valores_a_ler
Saída
PRINT *,lista_parâmetros_onde_guardar_os_valores_a_visualizar
Exemplos:
READ *, x, y
PRINT *,”A Maria vai de férias a “, cid
Exemplo (mostra diferentes modos de introduzir valores)
INTEGER :: a,b
...
PRINT *,”Insira dois valores”
READ *, a, b
...
>Insira dois valores

12 15 os valores são inseridos com um espaço entre eles
12;15 os valores são inseridos com um ponto e vírgula entre eles
FORTRAN

12
15 os valores são inseridos com um enter entre eles (mais usual)
Exemplo – Declaração implícita
PROGRAM Area_de_uma_circunferencia
READ *,raio
area = PI * raio * raio
PRINT *,”A área é de “, area
END
Exemplo – Declaração explícita
PROGRAM Circulo_Area_Perimetro
IMPLICIT NONE
REAL :: raio, perimetro, area
PRINT *,”Qual o raio da circunferência?”
READ *,raio
perimetro = 2 * PI * raio
PRINT *,”O perímetro é: “,perimetro
area = PI * raio * raio
PRINT *,”A área é de “, area
END
FORTRAN
Operadores aritméticos
Operadores binários
+ Adição
- Subtracção
* Multiplicação
/ Divisão
** Exponenciação
Operadores unários
- Negação
+ Positivo
Operadores aritméticos – Regras de aplicação
O Fortran não admite expressões com dois ou mais operadores aritméticos

consecutivos. Ex: a * - b (é errado).
Em Fortran não existe a multiplicação implícita, isto é: z (x + y) deve ser
escrito da seguinte forma z * (x + y).
É possível utilizar parêntesis em expressões aritméticas, servindo estes para
alterar a prioridade dos operadores, ou seja, qualquer sub-expressão que se
encontre entre parêntesis é determinada antes da restante expressão.
Divisão entre inteiros e reais
Uma operação aritmética entre dois valores (ou variáveis) inteiros,

resulta sempre num inteiro. Ex:
FORTRAN
6/2=3 7/2=3 1/2=0 0+2=2 2*3=6
Uma operação aritmética entre dois valores (ou variáveis) reais, ou entre um
real e um inteiro (ou vice versa), resulta num real. Ex:
6. / 2. = 3. 7. / 2 = 3.5 1 / 2. = 0.5 0. + 2 = 2. 2 * 3. =
6.
Chama-se a atenção para o resultado das seguintes expressões (em alguns

computadores/sistema):
3. * (1. / 3.) 1. 2. * (1. / 2.) = 1
Exponenciação
O cálculo a ** b, com b inteiro, mais não é do que multiplicar a por a, b vezes.

Exemplo:
2 ** 3 = 2 * 2 * 2 = 8
Já o cálculo a ** b, com b real, não é viável ser determinado segundo o método

anterior.
Exemplo:
2 ** 2.5 = ???
Neste último caso utiliza-se normalmente a seguinte expressão algébrica:
y x = e x ln y
logo para o exemplo anterior, ficaria: 2 2.5 = e 2.5 ln 2
FORTRAN
Prioridade dos operadores

Em primeiro lugar determina o valor das expressões entre parêntesis,
começando pelo par de parêntesis mais interior da expressão (caso exista
mais do que um).
Ex: 2 * (3 + 2 * (5 - 3)) = 2 * (3 + 2 * 2) = 2 * (3 + 4) = 2 * (7) = 2 * 7 = 14
Em segundo calcula as expressões com expoentes, da direita para a

esquerda.
Ex: 3 ** 2 ** 1 = 3 ** 2 = 9
Em terceiro calcula as expressões com operadores de multiplicação e

divisão, da esquerda para a direita.
Ex: 2 * 3 * 4 = 6 * 4 = 24
Por último, determina as expressões com operadores de adição e subtracção.
Nota: Caso o - e o + sejam aplicados, respectivamente, como operadores de

negação e de indicação de número positivo, então têm precedência sobre os
demais.
I. Considere as seguintes variáveis e respectivas inicializações:
a = 3. b = 2. c = 5. d = 4.
e = 10. f = 2. g = 3.
Determine o resultado de cada uma das seguintes expressões:
1) a * b + c * d + e / f**g 6) a**b**g
2) a * (b + c) * d + (e / f)**g 7) a / (g / b)
FORTRAN
3) a * (b + c) * (d + e) / f**g 8) (a / g) / b
4) a**(b**g) 9) a / g / b
5) (a**b)**g
II. Elabore as expressões (formulas) para cada uma das seguintes situações:
1) A média de duas notas.
2) A área de um quadrado e o volume de um cubo.
3) Dada a velocidade inicial, a aceleração e o tempo, calcular o espaço
percorrido.
Operador de atribuição
var = expressão
Operadores relacionais
== .EQ. Igual
/= .NE. Diferente
> .GT. Maior do que
>= .GE. Maior ou igual a
< .LT. Menor do que
<= .LE. Menor ou igual a
Exemplos:
2<4 .TRUE.
2 <= 4 .TRUE.
3 == 4 .FALSE.
FORTRAN
‘A’ < ‘B’ .TRUE.
Prioridade dos operadores relacionais
A prioridade é sempre inferior à dos operadores aritméticos.

7 + 3 < 2 + 11 1 / 3 == 0
10 < 13 0 == 0
.TRUE. .TRUE.
Operadores Lógicos
e1 .AND. e2 Resulta em .TRUE. se e1 e e2 são ambos .TRUE..

e1 .OR. e2 Resulta em .TRUE. se e1 ou e2 é .TRUE..
e1 . EQV. e2 Resulta em .TRUE. se e1 for igual (valor lógico) a e2.
e1 . NEQV. e2 Resulta em .TRUE. se e1 for diferente (valor lógico) de e2.
.NOT. e Resulta na negação de e.
Prioridade dos operadores Lógicos
Os operadores lógicos têm sempre menor prioridade do que os

operadores relacionais e como tal, menor do que a dos operadores aritméticos.
Mas entre si, a prioridade é a seguinte:
O mais prioritário é o .NOT..
O segundo mais prioritário é o .AND. (da esquerda para a direita).
O terceiro mais prioritário é o .OR. (da esquerda para a direita).
Os últimos que são processados são o .EQV. e o .NEQV..
FORTRAN
Indique quais das seguintes expressões são válidas em FORTRAN:

a) 5.5 >= 5 b) 20 > 20
c) .NOT. 6 > 5 d) 15 <= ‘A’
e) .TRUE. > .FALSE. f) 35 / 17. > 35 > 17
g) 7 <= 8 .eqv. 3 / 2 ==1 h) 17.5 .AND. (3.3 > 2)
Funções intrínsecas
São funções que fazem parte da própria linguagem FORTRAN.
Valor_de_retorno = Nome_da_função (lista_argumentos)
Exemplos:
SQRT(X) Raiz quadrada de X
Parâmetro: REAL
Valor de retorno: REAL
ABS(X) Valor absoluto de X

Parâmetro: REAL / INTEGER
Valor de retorno: REAL / INTEGER
ACHAR(I) Devolve o i-néssimo caracter da sequência de

caracteres que formam o código ASCII.
Parâmetro: INTEGER
FORTRAN
Valor de retorno: CHARACTER

IACHAR(C) Devolve a posição do caracter C na sequência
de caracteres do código ASCII.
Parâmetro: CHARACTER
Valor de retorno: INTEGER
SIN(X) Seno de X
Parâmetro: REAL (Radianos)
COS(X) Coseno de X
TAN(X) Tangente de X
ASIN(X) Arco seno de X

Parâmetro: REAL
Valor de retorno: REAL (Radianos)
ACOS(X) Arco coseno de X

Parâmetro: REAL
ATAN(X) Arco tangente de X
FORTRAN
Parâmetro: REAL
EXP(X) eX
Parâmetro: REAL
LOG(X) ln X
Parâmetro: REAL
LOG10(X) log10 X
Parâmetro: REAL
INT(X) Parte inteira de X

Parâmetro: REAL
FRACTION(X) Devolve a parte fraccionária de X

Parâmetro: REAL
REAL(I) Converte o valor inteiro I para real

Parâmetro: INTEGER
MOD(A,B) Resto da divisão inteira de A por B
FORTRAN
Parâmetro: INTEGER
MAX(A,B) Máximo entre A e B

Parâmetro: REAL/INTEGER
Valor de retorno: REAL/INTEGER
MIN(A,B) Mínimo entre A e B

Valor de retorno: REAL/INTEGER
NINT(X) Devolve o inteiro mais próximo de X

Parâmetro: REAL
FLOOR(X) Devolve o maior inteiro menor ou igual a X

Parâmetro: REAL
DBLE(X) Converte X para um DOUBLE PRECISION

Valor de retorno: DOUBLE PRECISION
SINH(X) Seno hiperbólico de X

Parâmetro: REAL
COSH(X) Coseno hiperbólico de X
FORTRAN
Parâmetro: REAL
TANH(X) Tangente hiperbólica de X

Parâmetro: REAL
KIND(X) Devolve o tipo de X

Parâmetro: INTEGER/REAL/...
LEN(S) Devolve o tamanho (nº caracteres) da string S

Parâmetro: STRING
CMPLX(X,Y) Converte o par de valores (X,Y) num complexo

Parâmetro: REAL
Valor de retorno: COMPLEX
CONJG(X) Devolve o conjugado de X

Parâmetro: COMPLEX
Valor de retorno: COMPLEX
Utilização das funções intrínsecas
y = TAN(3.1415)
y = SIN(PI)
y = REAL(n)
FORTRAN
y = COS(SQRT(X))
1) Qual a saída dos seguintes programas?
PROGRAM exemplo1
IMPLICIT NONE
INTEGER :: i1, i2, i3
REAL :: a1 = 2.4, a2
i1 = a1
i2 = INT(a1 * i1)
i3 = NINT(a1 * i1)
a2 = a1 ** i1
PRINT *, i1, i2, i3, a1, a2
END PROGRAM
PROGRAM exemplo2
IMPLICIT NONE
INTEGER :: i
LOGICAL :: l
REAL :: a
a = 0.5
i = nint(2. * 3.141593 / a)
l = i > 100
a = a * (5 / 3)
PRINT *, i, a, l
FORTRAN
END PROGRAM
2) Para o seguinte programa diga quais os valores visualizados na saída, se a

entrada for:
1, 3, 2, 45., 30.
PROGRAM exemplo3
IMPLICIT NONE
INTEGER :: i, j, k
REAL :: a, b, c
READ *, i, j, k, a, b
c = SIN((3.141593 / 180) * a)
PRINT *, i, j, k, a, b, c
END PROGRAM
3) Determine o coseno hiperbólico de x = 3.0 sabendo que cosh x = (ex+e-x)/2.

4) Determine o coseno hiperbólico de x = 3.0 utilizando a função intrínseca
COSH(X).
5) Determine a hipotenusa de um triângulo rectângulo.
6) Determine a distância entre dois pontos num espaço bidimensional.
Novamente as funções de Input/Output
PRINT *, lista_parâmetros
READ *, lista_parâmetros
WRITE (*,*) lista_parâmetros

READ (*,*) lista_parâmetros
FORTRAN
A lista de parâmetros das funções de saída podem ser compostas por:

constantes, variáveis, funções e expressões.
Os valores lógicos .TRUE. e .FALSE. são enviados para a saída como, T

e F, respectivamente.
Variáveis não inicializadas
PROGRAM xxxx PROGRAM yyyy

INTEGER :: n INTEGER :: n, m
PRINT *, n m=n*2
END PRINT *, m
END
Dependendo do compilador, uma variável não inicializada pelo

programador, pode:
Conter um valor atribuído pelo compilador.
Conter o valor que se encontra na posição de memória atribuída à
variável.
Estruturas condicionais – IF ... THEN ...
IF (Expressão_lógica) instrução
verd.
Exp
[nome:] IF (Expressão_lógica) THEN

Lista_Inst.
Lista_instruções
FORTRAN
END IF [nome]
Lista_instruções
ENDIF [nome]
Exemplos
Dados dois números, indicar se estes são iguais.

PROGRAM Numeros_Iguais
IMPLICIT NONE
INTEGER :: a, b
PRINT *,”Introduza o primeiro valor”
READ *, a
PRINT *,”Introduza o segundo valor”
READ *, b
IF ( a==b ) PRINT *,”Os valores são iguais”
END
Dados dois valores, ordená-los por ordem crescente.

PROGRAM Ord_Dois_Num
IMPLICIT NONE
INTEGER :: a, b, temp
PRINT *,”Introduza dois valores”
READ *, a, b
meu_if : IF ( a > b ) THEN
temp = a
a=b
b = temp
FORTRAN
ENDIF meu_if
PRINT *, a, b
END
Estruturas condicionais – IF ... THEN ... ELSE ...

falso verd.
Lista_instruções1 Exp
ELSE
Lista_Inst2 Lista_Inst1
Lista_instruções2
END IF [nome]
Exemplos
Exemplo 1
Dados dois valores, ordená-los por ordem crescente.
PROGRAM Ord_Dois_Numeros
IMPLICIT NONE
INTEGER :: a, b
PRINT *,”Introduza dois valores”
READ *, a, b
IF ( a < b ) THEN
PRINT *, a, b
ELSE
PRINT *, b, a
ENDIF
FORTRAN
END
Exemplo 2
PROGRAM CalRaizes
IMPLICIT NONE
REAL :: a, b, c, x1, x2
PRINT *, “Introduza os coeficientes a, b, e c”
READ *, a, b, c
IF (b**2 – 4 * a * c .GE. 0) THEN
PRINT ,”X1=”, (-b + SQRT(b**2 – 4 * a * c)) / (2 * a)
PRINT ,”X2=”, (-b - SQRT(b**2 – 4 * a * c)) / (2 * a)
ELSE
PRINT *,”Não há raízes reais”
END IF
END
A seguir apresentamos outra forma de resolver o mesmo problema, neste caso
usando uma variável auxiliar denominada temp.
PROGRAM CalRaizes1
IMPLICIT NONE
REAL :: a, b, c, x1, x2, temp
PRINT *, “Introduza os coeficientes a, b, e c”; READ *, a, b, c
temp = b**2 – 4 * a * c
IF (temp .GE. 0) THEN
PRINT ,”X1=”, (-b + SQRT(temp)) / (2 * a)
PRINT ,”X2=”, (-b - SQRT(temp)) / (2 * a)
ELSE
END IF
END
FORTRAN
De referir que esta última solução é mais apropriada porque o cálculo de delta
(cálculo de b**2 – 4 * a * c ) é apenas efectuado uma única vez.
Estruturas condicionais encadeadas

Apresentamos algumas situações com a utilização de estruturas
condicionais encadeadas (ou encaixadas).
Situação 1
IF (Expressão_lógica1) THEN
Lista_instruções1
ELSE
Lista_instruções2
Lista_instruções3
END IF
Lista_instruções4
END IF
Situação 2
Lista_instruções1
ELSE
Lista_instruções2
END IF
END IF
Situação 3
Lista_instruções1
FORTRAN
ELSE IF (Expressão_lógica2) THEN

Lista_instruções2
END IF
Situação 4
Lista_instruções1
Lista_instruções2
...
ELSE
Lista_instruções3
END IF
Ainda o exemplo 2, que efectua a resolução de equações de 2º grau

utilizando a formula resolvente, mas agora rescrito de outra forma.
...
REAL :: a, b, c, x1, x2, temp
PRINT *, “Introduza os coeficientes a, b, e c”; READ *, a, b, c
temp = b**2 – 4 * a * c
IF (temp .EQ. 0) THEN
PRINT *,”A raiz é”, -b / (2 * a)
ELSE IF (temp .GT. 0) THEN
PRINT ,”X1=”, (-b + SQRT(temp)) / (2 * a)
PRINT ,”X2=”, (-b - SQRT(temp)) / (2 * a)
ELSE
END IF
FORTRAN
END
1) Implemente um programa que dado o valor de t, calcule o f(t), sabendo que:
3* t 2 + 5 t 0
f (t ) =
3*t 2 + 5 t<0
2) Implemente um programa que dado o valor de x e de y, calcule o f(x,y),
sabendo que:
x+ y x y y 0
x + y2 x 0 y <0
f (x, y) =
x2 + y x<0 y 0
x2 + y 2 x <0 y <0
3) Implemente um programa que dado um caracter indique se este pertence ao
alfabeto e, em caso afirmativo, se é minúsculo ou maiúsculo.
4) Implemente um programa que dado um número inteiro diga se este é ou não

divisível por 2.
Estruturas condicionais encadeadas
[nome:] SELECT CASE (Expressão)

CASE (Selector1)
Lista_instruções1
CASE (Selector2)
Lista_instruções2
...
[CASE DEFAULT
Lista_instruçõesn+1 ]
FORTRAN
END SELECT [nome]

A Expressão deve resultar num inteiro, caracter ou valor lógico.
Cada selectori pode representar um único valor ou conjunto de
valores.
CASE(‘A’) Um único valor do tipo caracter

CASE(10) Um único valor do tipo inteiro
CASE(:5) Conjunto de valores
CASE(20:) Conjunto de valores
CASE(2:6) Conjunto de valores ( [2;6] )
CASE(2,3,4,5,6) Conjunto de valores ( {2,3,4,5,6} )
O SELECTOR CASE executa as operações do primeiro CASE que

encontrar cujo Selector inclua o valor obtido para a Expressão.
Isto não significa no entanto que seja possível dois CASE abrangerem
um mesmo valor da expressão condicional, isto é, os CASE’s devem
ser mutuamente exclusivos entre si.
Caso não seja encontrado nenhum CASE que satisfaça a Expressão,
então são executadas as operações do CASE DEFAULT (se este
existir).
Exemplo – Atribuição de notas qualitativas
PROGRAM Nota_Qualitativa
IMPLICIT NONE
INTEGER :: nota
PRINT *,”Insira uma nota”
READ *, nota
FORTRAN
SELECT CASE (nota)

CASE(1:5)
PRINT *,”Mau”
CASE(6:9)
PRINT *,”Insuficiente”
CASE(10:14)
PRINT *,”Suficiente”
CASE(15:17)
PRINT *,”Bom”
CASE(18:20)
PRINT *,”Excelente”
CASE DEFAULT
PRINT *,”Classificação errada”
END SELECT
END
Ciclo infinito
DO
Lista_instruções Lista_Inst.
END DO
Ciclo com instrução IF Lista_Inst1
DO verd.
Cond.
Lista_instruções1
falso
IF (Condição) EXIT
Lista_instruções2 Lista_Inst2
FORTRAN
END DO
Exemplos
Ler continuamente um número inteiro e indicar se este é positivo ou

negativo.
PROGRAM Positivo_Negativo
IMPLICIT NONE
INTEGER :: n
DO
PRINT *,”Insira um número”
READ *,n
IF (n .GE. 0) THEN
PRINT *,”É positivo”
ELSE
PRINT *,”É negativo”
END IF
END DO
END
Ler continuamente um número inteiro e indicar se este é positivo ou
negativo. Caso seja zero o programa deve terminar.
PROGRAM Positivo_Negativo
IMPLICIT NONE
INTEGER :: n
DO
PRINT *,”Insira um número”
READ *,n
FORTRAN
IF (n ==0) EXIT
IF (n .GT. 0) THEN
PRINT *,”É positivo”
ELSE
PRINT *,”É negativo”
END IF
END DO
END
Calcular a média dos alunos de uma turma.
PROGRAM media
IMPLICIT NONE
INTEGER, PARAMETER :: nalunos =30
INTEGER :: nota, cont = 1, stotal = 0
DO
IF ( cont > nalunos) EXIT
PRINT *,”Insira a nota do aluno n.”, cont
READ *, nota
stotal = stotal + nota
cont = cont + 1
END DO
PRINT *,”A média é:”, stotal / REAL(nalunos)
END
Ciclo com incremento
DO VarInc = Vinicial, Vfinal [, Vincremento]
Lista_de_instruções
FORTRAN
END DO
Vinicial, Vfinal e Vinvremento podem ser constantes, variáveis ou
expressões, que resultem num inteiro ou num real (desaconselha-se a
utilização deste último).
VarInc é uma variável que no início do ciclo assume o valor de Vincial e
por cada iteração vai incrementar (ou decrementar) em Vincremento
unidades, até que o seu valor exceda (acima ou abaixo) Vfinal.
Por omissão o valor de Vincremento é 1.
Se Vincremento for positivo e se o Vinicial exceder Vfinal, ou se
Vincremento for negativo e Vfinal for inferior a Vinicial, então o ciclo
não executa nenhuma iteração.
Exemplos
Calcular novamente a média dos alunos de uma turma.
PROGRAM media
IMPLICIT NONE
INTEGER :: nota, cont, stotal = 0
DO cont = 1, nalunos
READ *, nota
END DO
END
FORTRAN
Calcular o factorial de um valor a inserir.
PROGRAM factorial
IMPLICIT NONE
INTEGER :: fact = 1, n, val
PRINT *,”Valor?”
READ *, val
DO n = 2, val
fact = fact * n
END DO
PRINT *,”O factorial de “,val, “ é ”,fact
END
Calcular novamente o factorial de um valor a inserir.
PROGRAM factorial
IMPLICIT NONE
READ *, val
DO n = val, 2, -1
fact = fact * n
END DO
END
FORTRAN
Calcular o factorial de um valor a inserir.
PROGRAM factorial
IMPLICIT NONE
DO ! este ciclo serve para validar o número introduzido
READ *, val
IF (val >= 0) EXIT
PRINT *,”Valor inválido!!!”
ENDDO
DO n = 2, val
fact = fact * n
ENDDO
END
Contornar a utilização de reais em ciclos com incremento
O programa seguinte determina os valores de f(x) = x2-x+1 para x

compreendido entre [1,2] de 0.1 em 0.1.
PROGRAM fx
IMPLICIT NONE
REAL :: x
INTEGER :: n
DO n = 10, 20
FORTRAN
x = n / 10.
PRINT *, x**2 – x + 1
ENDDO
END
Ciclo com condição WHILE
DO WHILE ( Condição )
Lista_de_instruções
END DO
Condição é uma expressão do tipo lógico, isto é, resulta num valor do

tipo .TRUE. ou .FALSE..
O ciclo só se realiza caso a Condição seja verdadeira.
O ciclo continua a iterar enquanto a Condição for verdadeira.
Exemplos
Calcular novamente a média dos alunos de uma turma.
PROGRAM media
IMPLICIT NONE
INTEGER :: nota, cont = 1, stotal = 0
DO WHILE (cont <= nalunos)
FORTRAN

READ *, nota
cont = cont + 1
END DO
END
Determine o maior valor de uma sequência, com início em 1, cuja soma

dos elementos não exceda um dado valor inserido pelo utilizador.
PROGRAM exDoWhile
IMPLICIT NONE
INTEGER :: max, tsoma = 0, n = 0
PRINT *,”Insira o valor da soma”
READ *,max
DO WHILE ( tsoma < max)
n=n+1
tsoma = tsoma + n
END DO
PRINT *,”O valor é:”, n-1
END
Exemplo com ciclos aninhados (ou encaixados)
Apresentar o resultado do produto de todas as combinações de valores

pertencentes ao conjunto {1,2,3,4}
PROGRAM ExCiclosAninhados
FORTRAN
IMPLICIT NONE
INTEGER :: i, j
DO i = 1, 4
DO j = 1, 4
PRINT *, i * j
END DO
END DO
END
EXIT e CYCLE
EXIT como já se viu serve para terminar abruptamente a execução de um

ciclo, continuando o programa na instrução que se segue ao ciclo.
No caso de dois ou mais ciclos encadeados, o EXIT aborta apenas o ciclo
mais interior ao qual está inserido.
DO
DO
EXIT
PRINT *,”segundo ciclo” ! Não chega a ser executada
END DO
PRINT *,”primeiro ciclo” ! Imprime apenas esta mensagem
END DO
O CYCLE permite interromper a actual iteração, continuando a execução a

partir da primeira instrução do ciclo, desde que:
Se for um ciclo do tipo DO while (Condição) ..., a Condição continue a
resultar no valor lógico .TRUE..
FORTRAN
Se for um ciclo do tipo DO Var = Vinicial, Vfinal, Incremento ..., Var

faça parte do intervalo entre [Vinicial, Vfinal] se for positivo, caso
contrário entre o intervalo [Vfinal, Vinicial].
Neste último tipo de ciclo, a execução do CYCLE força na mesma o
incremento (ou decremento) de Var.
1) Implemente um programa para converter caracteres de minúsculos para

maiúsculos. Sempre que um caracter for inválido, (não pertencer ao
alfabeto) deve voltar a pedir novo caracter, a única excepção é para o
caracter ‘0’ que indica que deve sair do ciclo e terminar o programa.
2) O sen(x) pode ser calculado com base na soma dos termos de uma série
infinita, do tipo:
3
x x5 x7
sen( x) = x + + ...
3! 5! 7!
A nível computacional não é viável calcular o valor da série até ao infinito,
pelo que o sen(x) é calculado com um dado erro através da seguinte função:
N
x 2n 1
sen( x) = ( 1) n 1
n =1 (2n 1)!
Para um dado valor x, determine o N que permite obter o sen(x) com a mesma
precisão da função intrínseca SIN(X).
Entrada e saída de dados com formato

PRINT format_specifier, output_list
WRITE (output_device, format_specifier) output_list
READ (input_device, format_specifier) input_list
FORTRAN
O primeiro parâmetro (output_device e input_device) das instruções WRITE

e READ identificam respectivamente a saída e entrada de dados.
O caracter ‘*’ representa o valor por defeito, isto é, a entrada e a saída por
defeito (normalmente o teclado e o monitor).
O format_specifier é uma string ou label que descreve o formato dos dados,
para entrada ou para saída.
Exemplos
PRINT *,”Vai sair o próximo número” ! Sem formato
PRINT ‘(A,I2)’, “Atenção ao número”, 23 ! Com formato
500 FORMAT(A,I2,A)
PRINT 500,”Eu tenho o número”, 23, “. Acertei!”
WRITE (*,500) “Eu também tenho o número”, 23, “Também acertei!”
FORMAT
label FORMAT(Lista_formatadores_e_strings)
Descritores de formato
Iw Iw.m Integer Data

Bw Bw.m Integer Data in Binary form
Ow Ow.m Integer Data in Octal form
Zw Zw.m Integer Data in Hexadecimal form
Fw.d Real Data in decimal form
Ew.d Ew.dEe Real Data in Exponention notation (0.1-1.0)
ESw.d ESw.dEe Real Data in Exponention notation (1.0-10.0)
ENw.d ENw.dEe Real Data in Engineering notation
Gw.d Gw.dEe General I/O descriptor
A Aw Character Data
FORTRAN
Apresentamos a seguir os caracteres especiais de controlo:

“x ... x” ou ‘x ... x’ Character String
Lw Logical data
Tc TLn TRn Tab descriptor
nX Horizontal spacing
/ Vertical spacing
: Format scanning control
Número de repetições
rIw - rIw.m
O significado de cada um dos caracteres utilizados nos descritores de

formato é:
w Constante inteira positiva que especifica o tamanho do campo.

m Constante inteira não negativa que especifica o número mínimo de
dígitos a ler ou a visualizar.
d Constante inteira não negativa que especifica o número de dígitos
a representar à direita da virgula decimal.
e Constante inteira não negativa que especifica o número de dígitos
em expoente.
x Um qualquer caracter x.
c Uma constante inteira positiva que representa a posição do
caracter (coluna).
n Uma constante inteira positiva que especifica o número de
caracteres a manter.
FORTRAN
Espaçamento vertical
Caracter de Imagem da linha a imprimir
controlo
vertical
1 2 133
espaço - Espaçamento vertical normal (avança para a próxima linha

de impressão).
0 - Espaçamento duplo (avança uma linha).
1 - Avança para o topo da próxima página.
+ - Sobrepõe a última linha impressa.
Exemplo:
FORMAT(‘1’, ...)
Arrays
Consiste numa sequência de variáveis ou constantes, todas elas do

mesmo tipo, representadas globalmente por único identificador e
individualmente por esse mesmo identificador mais um índice.
...
a(1) = 540
Memória
a(2) = 912 array a
do
computador a(3) = 123
a(4) = 321
...
FORTRAN
Declaração de arrays
Tipo_dos_elementos_do_array, DIMENSION(Dimensão_array) :: Lista_de_arrays
Tipo_dos_elementos_do_array INTEGER | REAL | ...
Dimensão_array INTEGER | INTEGER:INTEGER
Exemplo:
INTEGER, DIMENSION(4) :: a ! a(1), a(2), a(3) e a(4)
Acesso aos elementos do array
Exemplo1:
REAL, DIMENSION(10) :: LstNotas
LstNotas(1) = 10
LstNotas(10) = 15.5
PRINT *,”A nota 1 é “, LstNotas(1)
Exemplo2:
REAL, DIMENSION(5) :: a
READ *, a(2)
a(3) = (a(1) + a(2)) / 2
FORTRAN
Inicialização de arrays
A inicialização dos arrays pode ser feita segundo uma das seguintes
formas:
Utilizando expressões de atribuição;
Iniciar aquando da declaração das variáveis;
Utilizando instruções de entrada ( ex: READ).
Utilizando expressões de atribuição

REAL, DIMENSION(5) :: array1
INTEGER :: i
DO i = 1, 5
array1( i ) = i * 0.1
END DO
O que é equivalente a:
array1 = (/ 0.1, 0.2, 0.3, 0.4, 0.5 /)
Inicialização aquando da declaração das variáveis

REAL, DIMENSION(5) :: array1 = (/ 0.1, 0.2, 0.3, 0.4, 0.5 /)
Se o valor for igual para todos os elementos, é possível utilizar a
seguinte expressão:
REAL, DIMENSION(5) :: array1 = 0.0
Utilizando instruções de entrada

INTEGER :: i
FORTRAN
DO i = 1, 5
READ *, array1( i )
END DO
Ciclo DO implícito
(Arg1, Arg2, ..., Índice = Vinicial, Vfinal, Incremento)
Exemplos:
REAL, DIMENSION(500) :: array1 = (/ (0.0, i = 1, 500) /)
INTEGER, DIMENSION(500) :: array2 = (/ (i, i = 1, 500) /)
INTEGER, DIMENSION(25) :: array3 = (/ ( (0, i = 1, 4), 5*j, j = 1, 5) /)
Limites do array
Por defeito um array de tamanho n começa no elemento 1 e termina no

elemento n. É no entanto possível alterar estes limites da seguinte forma:
Tipo_dos_elementos_do_array, DIMENSION(Dimensão_array) :: Lista_de_arrays
Dimensão_array Limite_inferior : Limite_superior
Exemplo:
REAL, DIMENSION(-2:2) :: a =(/ -2.0, -1.0, 0.0, 1.0, 2.0 /)
Utilização de constantes na declaração de arrays

INTEGER, PARAMETER :: TARRAY = 20
REAL, DIMENSION(TARRAY) :: LstVal
FORTRAN
Exemplo:
Determinar o máximo valor de um array.
PROGRAM Maximo
IMPLICIT NONE
INTEGER, PARAMETER :: TARRAY = 100
REAL, DIMENSION(TARRAY) :: array
REAL :: max
INTEGER :: i
! Inicialização do array ...
max = array(1)
DO i = 2, TARRAY
IF( max < array(i) ) max = array(i)
END DO
PRINT *,”Máximo = “, max
END
Calcular a média de 10 valores reais a inserir pelo utilizador e indicar

quais desses valores é que são superiores à média.
PROGRAM media_superior
IMPLICIT NONE
INTEGER, PARAMETER :: NVAL = 10
REAL, DIMENSION(NVAL) :: lval
REAL :: soma = 0.0, media
INTEGER :: i
DO i = 1, NVAL
PRINT *,”Insira um valor”
FORTRAN
READ *, lval(i)
soma = soma + lval(i)
END DO
media = soma / NVAL
DO i = 1, NVAL
IF( lval(i) > media ) THEN
PRINT *,lval(i), “é superior à média”
END IF
END DO
END
1) Implemente um programa em que dado dois arrays de reais de dimensão

20, calcule o produto vectorial entre esses arrays.
2) Pretende-se que implemente um programa em que dados dois arrays de

inteiros de tamanho 10, A e B, obtenha um terceiro array C tal que C(i) é
igual ao máximo valor entre A(i) e B(i).
3) Para o problema anterior acrescente a seguinte condição: se o máximo entre

os valores dos arrays A(i) e B(i) for inferior a 10 então o valor na posição
C(i) é zero.
4) Implemente um programa capaz de armazenar as coordenadas de 10 pontos,

para posteriormente calcular a recta de regressão linear e o desvio padrão.
FORTRAN
Operadores sobre arrays
O Fortran é das poucas linguagens que permite que se aplique alguns dos
operadores escalares e funções implícitas aos arrays, desde que se garanta a
seguinte condição:
Caso o operador a utilizar seja do tipo binário em que ambos
operandos são arrays, então estes devem possuir a mesma estrutura,
isto é, a mesma dimensão e os mesmos limites.
Exemplo 1:
INTEGER, DIMENSION(10) :: a, b, c
...
a=b+c ! Assim é mais fácil
é equivalente a ter:
INTEGER, DIMENSION(10) :: a, b, c
...
DO i = 1, 10
a(i) = b(i) + c(i)
END DO
Exemplo 2:
INTEGER, DIMENSION(10) :: a, b
INTEGER :: K = 10
...
a=K*b ! Assim é mais fácil
INTEGER :: K = 10
FORTRAN
...
DO i = 1, 10
a(i) = K * b(i)
END DO
Exemplo3:
INTEGER :: m
...
a = abs(b)
m = maxval(a)
INTEGER :: m
...
DO i = 1, 10
a(i) = abs(b(i))
END DO
m = maxval(a)
Sub-arrays de um array
O Fortran admite aceder aos arrays como um todo, ou por partes (sub-
arrays), sendo estas representadas da seguinte forma:
Sub_limite_inferior : Sub_limite_superior : Incremento
O Incremento é opcional, significando a sua ausência que é igual a 1;
FORTRAN
O Sub_limite_superior é opcional, significando a sua ausência que o

sub-array se estende até ao limite superior do array original;
O Sub_limite_inferior é opcional, significando a sua ausência que o
sub-array se estende até ao limite inferior do array original.
Exemplos:
INTEGER, DIMENSION(10) :: array1 = (/ (i, i=1,10) /)
INTEGER, DIMENSION(5) :: array2 = array1(3:7), array3 = array1(2:10:2)
! array2 = (/ 3, 4, 5, 6, 7 /)
! array3 = (/ 2, 4, 6, 8, 10 /)
Strings
Representação
As strings (constantes) são sequências de caracteres limitadas, à
esquerda e à direita, pelo caracter aspas (“) ou plica (‘).
As variáveis para strings são declaradas com o tipo CHARACTER,
utilizando o atributo LEN para indicar a quantidade máxima de
caracteres que a variável poderá vir a conter.
Para o tamanho de uma string contam todos os caracteres que surjam
entre plicas, incluindo espaços, tabuladores ou outro qualquer tipo de
caracter invisível.
Declaração de strings
CHARACTER (LEN = Tamanho_string) :: Lst_strings
CHARACTER (Tamanho_string) :: Lst_strings
CHARACTER (*) :: Lst_strings_vs_atribuição
FORTRAN
Exemplo:
CHARACTER (7) :: a = “BOM DIA”
Inicialização de strings
Na declaração
CHARACTER (*) :: a = “BOM DIA”
Por atribuição
CHARACTER (7) :: a
a = ‘BOM DIA’
Com instruções de entrada (READ)
CHARACTER (7) :: a
READ *, a
Sub-strings
O Fortran admite que se aceda a parte de uma string à semelhança do

que se pode fazer com os arrays.
Exemplos:
CHARACTER (*) :: a = “BOM DIA”
CHARACTER (3) :: b, c
b = a(1:3)
c = a(5:7)
PRINT *, b, “ “, c ! dá BOM DIA
PROGRAM exemplo
IMPLICIT NONE
CHARACTER (8) :: a, b, c
FORTRAN
CHARACTER :: z
a = ‘ABCDEFGH’ ! a = ‘ABCDEFGH’
b = ‘12345678’ ! b = ‘12345678’
c = a(5:7) ! c = ‘EFG em que caracter espaço
b(7:8) = a(2:6) ! b = ‘123456BC’
z = a(1:1) ! z = ‘A’
END
Strings – Operador de concatenação
Concatenar a string s1 com a string s2 significa juntar s2 ao fim de s1. O

Fortran permite este tipo de operação através do operador (de concatenação)
‘//’.
Exemplo:
PROGRAM exemplo
IMPLICIT NONE
CHARACTER (10) :: a
CHARACTER (8) :: b, c
a = ‘ABCDEFGHIJ’ ! a = ‘ABCDEFGHIJ’
b = ‘12345678’ ! b = ‘12345678’
c = a(1:3) // b(4:5) // a(6:8) ! c = ‘ABC45FGH’
END
FORTRAN
Operadores relacionais com strings
O Fortran admite a comparação entre strings utilizando os vulgares

operadores relacionais, tendo no entanto em conta os seguintes aspectos:
Estes operadores realizam a comparação, caracter a caracter, segundo

a forma de representação dos caracteres utilizada pelo
compilador/sistema operativo, que normalmente é o standard ASCII
– American Standard Code for Information Interchange;
A comparação só é possível entre strings e não entre strings e outro
tipo de dados;
Para efeitos de comparação consideram-se todos os caracteres, sejam
eles minúsculos, maiúsculos, ditos invisíveis, etc (os caracteres
minúsculos consideram-se distintos dos caracteres maiúsculos);
A comparação inicia-se pelos caracteres mais à esquerda;
Se os caracteres forem distintos, é de imediato apurado o resultado da
expressão relacional. Para tal considera-se como a menor string
aquela cujo caracter é de menor valor decimal, segundo a convenção
estabelecida na representação dos mesmos. Por exemplo, segundo o
standard ASCII: ‘A’ < ‘B’ e ‘A’ < ‘a’;
Se ambos caracteres forem iguais, é então necessário comparar o
caracter seguinte de ambas as strings segundo os procedimentos do
ponto anterior;
Se todos os caracteres forem iguais as strings são lexicalmente iguais;
Se duas strings, s1 de tamanho n e s2 de tamanho m, tal que n < m,
possuem exactamente os mesmos n primeiros caracteres, resulta então
que s2 é lexicalmente maior que s1.
FORTRAN
Funções intrínsecas de comparação de strings
Por questões de portabilidade dos programas é conveniente assegurar

que a comparação entre strings se faça de forma independente do standard
utilizado para a representação dos caracteres.
Para tal o Fortran fornece um conjunto de funções intrínsecas que utiliza
sempre o standard ASCII para efeitos de comparação, são elas as seguintes:
LLT(s1,s2) Lexicalmente menor que

LLE(s1,s2) Lexicalmente menor ou igual que
LGT(s1,s2) Lexicalmente maior que
LGE(s1,s2) Lexicalmente maior ou igual que
Todas estas funções devolvem um valor do tipo LOGICAL, isto é,

.TRUE. ou .FALSE.. Por exemplo no primeiro caso, a função devolve o valor
lógico .TRUE. se a string s1 é lexicalmente menor que a string s2.
Outras funções intrínsecas para strings
CHAR(INTEGER) - Aceita um inteiro e devolve o respectivo caracter.

INTEGER :: i = 65
PRINT *, CHAR(i) ! ‘A’
ICHAR(CHARACTER) - Aceita um caracter e devolve o respectivo valor

inteiro.
CHARACTER :: c = ‘A’
PRINT *, ICHAR(c) ! 65
FORTRAN
ACHAR(INTEGER) - Semelhante ao CHAR(...) só que utiliza sempre o

standard ASCII.
IACHAR(CHARACTER) - Semelhante ao ICHAR(...) só que utiliza

sempre o standard ASCII.
LEN(STRING) - Devolve o número de caracteres de uma string.

CHARACTER(*) :: c = ‘ABC CBA’
PRINT *, LEN(c) !7
LEN_TRIM(STRING) - Devolve o número de caracteres sem os espaços em

branco.
CHARACTER(*) :: c = ‘ABC CBA’
PRINT *, LEN_TRIM(c) !6
INDEX(s1,s2) - Se a string s2 estiver contida na string s1, a função

devolve a posição de s1 onde começa s2.
PRINT *, INDEX(‘BOM DIA’, ‘DIA’) !5
Arrays de strings
O Fortran admite a utilização de array de strings, isto é, arrays cujos

elementos são strings, desde que se estabeleça um tamanho comum a todas.
Declaração
CHARACTER (12), DIMENSION(3) :: LstStr
LstStr(1) = ‘Olá tudo bem’
LstStr(2) = ‘Bem obrigado’
LstStr(3) = ‘De nada’
FORTRAN
Arrays multi-dimensionais
O Fortran admite a utilização de arrays multi-dimensionais, isto é,

arrays com duas ou mais dimensões.
Definição de arrays multi-dimensionais

Tipo_elementos_array, DIMENSION(Tam_1_dim, Tam_2_dim) :: Lst_arrays
Exemplo:
INTEGER, DIMENSION(3,5) :: a
a
1 2 3 4 5
Acesso aos elementos de um array multi-dimensional

identificador_array( pos_1_dim, pos_2_dim, ...)
Exemplo:
INTEGER, DIMENSION(2,3,5) :: array
INTEGER :: i
array(1,1,1) = 10
DO i = 1, 3
PRINT *, array(2, i, 3)
END DO
PRINT *, (array(2, i, 3), i =1, 3)
FORTRAN
Inicialização de arrays multi-dimensionais

INTEGER, DIMENSION(2,3) :: a = (/ 11, 12, 13, 21, 22, 23 /) !Errado
Função implícita RESHAPE

Array RESHAPE( Array a1, Array a2)
a1 - Array original
a2 - Estrutura do novo array
RETORNA: Um array com a estrutura de a2 e com os elementos de a1.
Exemplo:
INTEGER,DIMENSION(2,3) :: a= RESHAPE((/ 11,12,13,21,22,23 /), (/2, 3/))
Ciclos DO implícitos em arrays multi-dimensionais

INTEGER, DIMENSION(2,3,5) :: a
INTEGER :: x, y, z
DO x = 1, 2
DO y = 1,3
DO z = 1, 5
READ *, a(x,y,z)
END DO
END DO
END DO
É equivalente a ter:
INTEGER, DIMENSION(2,3,5) :: a
INTEGER :: x, y, z
READ *, (((a(x,y,z), z = 1,5), y = 1,3), x = 1,2)
FORTRAN
Sub-arrays de um array multi-dimensional
Para aceder a um sub-array dentro de um array multi-dimensional

aplica-se, para cada uma das dimensões, a estratégia utilizada para os arrays
unidimensionais.
(Sub_limite_inferior : Sub_limite_superior : Incremento,
Sub_limite_inferior : Sub_limite_superior : Incremento, ...)
As regras para Sub_limite_inferior, Sub_limite_superior e para o Incremento,

são as mesmas que se utilizaram para os arrays unidimensionais.
Exemplo:
INTEGER,DIMENSION(2,3,5) :: a = RESHAPE( ... )
INTEGER,DIMENSION(2,5) :: b = a(:, 2, :)
INTEGER,DIMENSION(2,2) :: b = a(:, 1:2, 1)
Instrução (construtor) Where
O Fortran através da instrução where permite condicionar o processo de

atribuição de valores aos elementos de um array, mediante determinada
condição (máscara).
NOTA: Esta instrução só existe nas versões do Fortran 90 e posteriores.
Sintaxe
[nome:] WHERE (máscara)
Expressão_Atribuição_Array
ELSEWHERE
Expressão_Atribuição_Array
END WHERE [nome]
FORTRAN
Exemplo:
DO i = 1, 10
DO j = 1, 5
IF ( a( i, j) > 0) THEN
b( i, j) = 1
ELSE
b( i, j) = 0
ENDIF
ENDDO
ENDDO
WHERE ( a(i, j) > 0 )
b( i, j) = 1
ELSEWHERE
b( i, j) = 0
ENDWHERE
O Fortran admite ainda uma versão curta da instrução where.
WHERE (máscara) Expressão_Atribuição_Array
Exemplo:
DO i = 1, 10
IF ( a( i ) < 0) a( i ) = 0
ENDDO
WHERE (a( i ) < 0 ) a( i ) = 0
FORTRAN
Instrução (construtor) Forall
O Fortran através da instrução Forall permite manipular secções de um

array de uma forma mais rápida e eficiente.
Tal como a instrução Where, também o Forall só existe nas versões do
Fortran 90 e posteriores. A sua criação deve-se em grande parte, às óptimas
características que apresenta para paralelização de programas.
Sintaxe
FORALL (expr1, ... , expr2, condição)
instr1
.
.
.
instrN
END FORALL
onde instr pode ser uma operação aritmética ou uma atribuição de apontadores
e expr tem o seguinte formato geral,
variável = limite_inferior : limite_superior : incremento
Caso o incremento não seja especificado o seu valor por defeito é 1.

A condição (ou máscara) também é opcional, quando especificada então
o conjunto de instruções do Forall apenas é executado quando esta for
verdadeira, caso contrário estas instruções são executadas para todos os índices
do array.
FORTRAN
Exemplo1:
FORALL (i = 1:m, j = 1:n)
x(i,j) = i+j
END FORALL
Que, usando ciclos DO encadeados é equivalente a ter:

DO i = 1, m
DO j = 1, n
x(i,j) = i+j
END DO
END DO
Exemplo2:
FORALL (i = 1:6, a(i) .NE. 0.0)
b(i) = 1.0 / a(i)
END FORALL
DO i = 1, 6
IF (a(i) .NE. 0.0) THEN
b(i) = 1.0 / a(i)
END IF
END DO
FORTRAN
Tipos de dados não primitivos
O Fortran, à semelhança da maior parte das linguagens modernas,

permite que o programador defina os seus próprios tipos de dados.
Definição
TYPE [::] Nome_do_tipo
Definições_das_componentes_do_tipo
END TYPE [Nome_do_tipo]
Exemplos:
TYPE Ponto TYPE Ponto3D
REAL :: x, y REAL :: x, y, z
END TYPE END TYPE
TYPE Data
INTEGER :: dia, mes, ano
END TYPE
Declaração de variáveis de tipos não primitivos

TYPE( Nome_do_tipo ) [, ...] :: Lista_variáveis
Exemplo:
TYPE(Ponto) :: p1, p2
FORTRAN
Inicialização das variáveis
Na declaração
TYPE(Nome_do_tipo)[,...] ::Variável = Nome_do_tipo(Valores_dos_campos)
Exemplo:
TYPE(Ponto) :: p1, p2 = Ponto(12., 45.5)
Por atribuição
Variável = Nome_do_tipo( Valores_dos_campos )
Exemplo:
p1 = ponto(0.0, 0.5)
Acesso aos campos

Nome_variável%Nome_campo
Exemplo:
PRINT *, p1%x
PRINT *, p2%y
Utilização de tipos não primitivos nas definições
Exemplos:
TYPE Recta
END TYPE
FORTRAN
TYPE Aluno
INTEGER :: nmec
CHARACTER (20) :: nome
TYPE(Data) :: dnasc
END TYPE
Acesso aos campos

TYPE(Aluno) :: al
al%nome = ‘Rita’
al%dnasc%dia = 3
Arrays de tipos não primitivos (ou arrays de registos)

TYPE( Nome_do_tipo ), DIMENSION(Tamanho) :: Lista_arrays
Exemplo:
TYPE( Ponto ), DIMENSION(10) :: LstPontos
Acesso aos elementos e campos

LstPontos(1)%x = 10.
LstPontos(2)%x = 0.5
LstPontos(3)%x = 1.2
Funções E/S com tipos não primitivos

TYPE Circulo
TYPE(Ponto) :: centro
REAL :: raio
END TYPE
TYPE(Circulo) :: c
READ *, c ! 12.5 5. 6.5
FORTRAN
Exemplo 1
Implementar um programa em que dados dois pontos de um quadrado,
indique qual a área do mesmo.
PROGRAM quadrado
IMPLICIT NONE
TYPE Ponto
REAL :: x, y
END TYPE
PRINT *, “Insira coordenadas do 1º ponto”
READ *, p1
PRINT *, “Insira coordenadas do 2º ponto”
READ *, p2
PRINT , “Área = “, (p2%x-p1%x)**2
END
Exemplo 1
Implementar um programa que indique quais os alunos da turma de AP
que obtiveram uma nota no teste superior à média (da turma).
PROGRAM Alunos
INTEGER, PARAMETER :: nalunos = 30
TYPE Aluno
CHARACTER(20) :: nome
REAL :: nota
END TYPE
TYPE(Aluno), DIMENSION(nalunos) :: Lst
FORTRAN
INTEGER :: i
REAL :: soma = 0, media
DO i = 1, nalunos
PRINT *,“Nome e nota do aluno nº “, i
READ *, Lst(i)%nome ! ou Lst(i) para ler os 2 campos
READ *, Lst(i)%nota
soma = soma + Lst(i)%nota
END DO
media = soma / REAL(nalunos)
DO i = 1, nalunos
IF(Lst(i)%nota > media) PRINT *, Lst(i)%nome
END DO
END
1) Implemente um programa que permita ler a informação sobre uma série de

pontos, calculando posteriormente os coeficientes da recta de regressão
linear.
2) Implemente um programa capaz de armazenar as notas a cada disciplina

para cada aluno do 1º ano de EQ e do 2º ano de EM (utilize tipos de dados
não primitivos).
FORTRAN
Procedimentos
É vulgar que ao longo de um programa seja necessário repetir

determinadas instruções, ou utilizar por diversas vezes instruções, que apesar
de não serem totalmente iguais, diferem apenas em alguns pormenores.
Seria certamente útil poder colocar essas instruções em evidência,
separando-as do programa principal, para que pudessem ser utilizadas sempre
que necessário. Permitindo assim, obter um programa melhor estruturado, mais
pequeno e até mais fácil de implementar, uma vez que grande parte do código
seria escrito uma única vez, mas reutilizado tantas as vezes quantas as
necessárias.
Este tipo de potencialidades é contemplada na grande maioria das
linguagens modernas através de funções e/ou subrotinas. O Fortran não é
excepção à regra e permite os dois tipos de estruturas.
Genericamente o conceito de procedimento serve para designar funções
e subrotinas. As funções já aqui foram utilizadas (funções implícitas),
caracterizam-se por aceitar zero ou mais parâmetros, em função dos quais
realiza um conjunto de instruções, retornando no fim um determinado valor.
O conceito de subrotina é muito semelhante ao de função, só que ao
contrário destas, as subrotinas não devolvem qualquer tipo de valor.
Vantagens:
Implementação e teste por módulos;

Reutilização de código;
Decomposição da solução do problema.
FORTRAN
Tipos de procedimentos
Em Fortran os procedimentos podem ser definidos segundo uma das três

seguintes formas:
Internas
Externas
Externas, implementadas em módulos
Procedimentos internos
São definidos dentro do próprio programa principal (PROGRAM),

também designado por programa hospedeiro;
Como tal são compilados em conjunto com o programa principal;
Este tipo de procedimentos só pode ser utilizado pelo programa
principal, e eventualmente, por outros procedimentos internos ao
hospedeiro;
Estes procedimentos podem partilhar as definições de tipos,
constantes e variáveis do programa principal;
No entanto as definições de tipos, constantes e variáveis do
procedimento não são visíveis pelo programa principal;
Estes procedimentos são implementados após a última instrução do
corpo do programa principal, mas antes do fim do programa (END
PROGRAM);
A divisão entre o corpo do programa principal e os procedimentos
faz-se através da instrução CONTAINS.
FORTRAN
Assim, um programa com implementação de procedimentos internos tem

a seguinte forma:
PROGRAM NomePrograma
Declarações
Corpo do Programa
CONTAINS
Procedimentos internos
END PROGRAM
Procedimentos externos
São implementados no mesmo ficheiro do programa principal;

São também compilados em conjunto com o programa principal;
Podem ser utilizados pelo programa principal e por todas as rotinas
neste contidas e até, eventualmente, por outros procedimentos
externos;
A única relação entre estes procedimentos e o programa principal são,
eventualmente, os parâmetros e o valor de retorno;
Estes procedimentos não partilham qualquer tipo de definição de
tipos, constantes ou variáveis com o programa principal;
Estes procedimentos são implementados após o fim do programa
(END PROGRAM).
PROGRAM NomePrograma
Declarações
Corpo do Programa
END PROGRAM
Procedimentos externos
FORTRAN
Procedimentos implementados em módulos
São implementados num ficheiro à parte daquele onde está o

programa principal;
Podem ser reutilizados em vários programas;
Permitem a implementação de bibliotecas de definições de tipos,
declaração de constantes, declaração de procedimentos e declaração
de interfaces;
Podem ser compilados separadamente do programa principal;
Para gerar o executável é necessário linkar o ficheiro com o programa
principal e o ficheiro com o módulo;
Por si só não permitem obter um executável;
Para que possam ser utilizados num qualquer programa é necessário
inclui-lo explicitamente, através da instrução USE;
Exemplo:
! Ficheiro com o módulo ! Ficheiro com o programa principal
MODULE Nome_do_Módulo PROGRAM NomePrograma
... USE Nome_do_Módulo
END MODULE Declarações
Corpo do Programa
END PROGRAM
Exemplo – Subrotina interna
PROGRAM Area_Circulo
IMPLICIT NONE
FORTRAN

REAL :: raio
PRINT *,”Insira o raio do círculo”
READ *, raio
CALL Det_Area(raio)
CONTAINS
SUBROUTINE Det_Area(r)
REAL, INTENT(IN) :: r
PRINT *,”Área do círculo = “, PI * r**2
END SUBROUTINE Det_Area
END PROGRAM
Exemplo – Subrotina externa
PROGRAM Area_Circulo
IMPLICIT NONE
REAL :: raio
PRINT *,”Insira o raio do círculo”
READ *, raio
CALL Det_Area(raio)
END PROGRAM
SUBROUTINE Det_Area(r)
REAL, INTENT(IN) :: r
PRINT *,”Área do círculo = “, PI * r**2
END SUBROUTINE Det_Area

FORTRAN
Subrotinas
Definição e implementação
Uma subrotina deve ser definida segundo a seguinte sintaxe:
SUBROUTINE Nome_Subrotina (Lista_Pârametros)
Declarações
Parte_Executável
[RETURN]
END SUBROUTINE [Nome_Subrotina]
Nome_Subrotina Identificador;
Lista_Parâmetros Lista de parâmetros;
Declarações Declarações dos parâmetros e variáveis;
Parte_Executável Corpo da subrotina.
Nome e lista de parâmetros

O nome de uma subrotina é o seu identificador, que como tal obedece
às normas estabelecidas pelo Fortran para os identificadores [a-z A-Z
0-9 _].
A lista de parâmetros consiste em zero ou mais parâmetros separados
por vírgulas.
A cada parâmetro está associado um tipo (INTEGER, REAL, não
primitivo, etc) e um atributo que classifica a finalidade do argumento.
Declaração dos parâmetros

Na parte dedicada às declarações deve constar, para além das variáveis
da própria subrotina, a declaração dos parâmetros segundo a seguinte sintaxe:

FORTRAN
Declarações tipo_parâmetro, INTENT(entrsaida) :: lista_parâmetros

Entrsaida IN | OUT | INOUT
Convém aqui realçar que os parâmetros funcionam como variáveis

locais, ou seja, apenas são visíveis dentro do procedimento para o qual estão
definidos.
Comportamento da subrotina
A utilização dos procedimentos pressupõe duas entidades, uma que
invoca o procedimento e outra que é invocada (o próprio procedimento). O
esquema seguinte mostra esta dualidade de entidades:
Função Origem
(Quem invoca)
Subrotina
(Quem é invocado)
....
Comportamento dos parâmetros

Os parâmetros funcionam para permitir passar valores entre quem invoca
e quem é invocado e vice-versa, ou até realizar em simultâneo a transferência
nos dois sentidos. Definem-se assim três tipos de parâmetros:
INTENT(IN) – Se o parâmetro for apenas de entrada, isto é, se
permitir passar informação apenas para a subrotina;
INTENT(OUT) – Se o parâmetro for apenas de saída, isto é, se
permitir passar informação da subrotina para quem invoca;

FORTRAN
INTENT(INOUT) – Se o parâmetro for simultaneamente de

entrada e de saída, isto é, tanto pode passar informação para
dentro da subrotina, como desta para quem a invoca.
O INTENT tanto pode ser um atributo, que pode ser utilizado aquando
da declaração dos parâmetros, ou uma instrução que assinala a intenção dos
parâmetros após estes terem sido declarados.
Tipo_parâmetro, INTENT(IN | OUT | INOUT) :: Lst_parâmetros
Ou:
Tipo_parâmetro :: Lst_parâmetros
INTENT(IN | OUT | INOUT) Lst_parâmetros
Exemplos: Parâmetros
Variável SUBROUTINE Soma(a,b)

Local REAL, INTENT(IN) :: a, b
REAL :: s
s=a+b
PRINT *,”Soma =”, s
END SUBROUTINE
SUBROUTINE Soma(a, b, c)
REAL, INTENT(IN) :: a, b
REAL, INTENT(OUT) :: c
c=a+b
END SUBROUTINE

FORTRAN
Invocação de uma subrotina

Uma vez definida a subrotina, pode então ser utilizada, quer pelo
programa, quer por outros procedimentos da seguinte forma:
CALL Nome_Subrotina( Lista_Parâmetros)
A lista de parâmetros pode consistir em constantes, variáveis ou até em

expressões, mas tudo depende da forma como foi definido o comportamento do
parâmetro.
Exemplo:
CALL Soma(10, 20)
1) Implemente uma subrotina que apresente a média de dois valores reais.
2) Implemente uma subrotina em que dados dois valores reais “devolva” a

média destes (SUBROUTINE).
3) Implemente uma subrotina em que dadas duas variáveis, troque os valores

nelas contidos.

FORTRAN
Variáveis estáticas
Uma variável local a um procedimento passa a existir a partir do momento

em que é declarada (quer implicitamente ou explicitamente), sendo
eliminada com o terminar da execução do procedimento.
Ou seja, por cada vez que um procedimento é invocado recriam-se
novamente todas as suas variáveis locais, daí que entre duas invocações de
um mesmo procedimento, não exista qualquer vínculo entre as respectivas
variáveis locais.
Nem sempre este comportamento é o desejável, há por vezes a necessidade
de forçar a que uma variável local mantenha o seu valor para além do fim
do procedimento. De tal forma que, quando novamente invocado o
procedimento, a variável continue não só a existir como ainda possua o
valor nela guardado.
Este tipo de variáveis designam-se por variáveis estáticas.
As variáveis são estáticas se aquando da sua declaração se utilizar o atributo

SAVE.
Exemplo:
SUBROUTINE Exemplo(a) PROGRAM Pexemplo
INTEGER, INTENT(IN) :: a ...
INTEGER, SAVE :: total_inv = 0 CALL Exemplo(10)
Total_inv = total_inv + 1 ...
... CALL Exemplo(20)
END SUBROUTINE ...
END

FORTRAN
Pode-se ainda utilizar a instrução SAVE, desde que esta seja colocada
imediatamente a seguir às declarações:

INTEGER :: total_inv = 0 CALL Exemplo(10)
SAVE :: total_inv ...
Total_inv = total_inv + 1 CALL Exemplo(20)
... ...
END SUBROUTINE END
A utilização da instrução SAVE sem argumentos significa que o valor de

todas as variáveis locais é salvaguardado:

INTEGER :: total_inv = 0 CALL Exemplo(10)
SAVE ...
Total_inv = total_inv + 1 CALL Exemplo(20)
... ...
END SUBROUTINE END
Funções em Fortran
Já vimos que as subrotinas permitem a passagem de parâmetros em ambos

sentidos;
A definição de função diz que é uma entidade que aceita um conjunto de
valores (parâmetros) e devolve um único valor;

FORTRAN
Em Fortran a definição de função é alargada permitindo, à semelhança das

subrotinas, passagem de parâmetros em ambos os sentidos;
Mas conforme a própria definição diz, também pode devolver um valor
(simples ou composto) através da própria função.
Sintaxe das funções

Tipo_Retorno_Função FUNCTION Nome_Função ( Lista_parâmetros)
! Zona de declarações da função
!Corpo da função
Nome_Função = expressão | READ *, Nome_Função
[RETURN]
...
END FUNCTION [Nome_Função]
Ou de outra forma:
FUNCTION Nome_Função ( Lista_parâmetros)
! Zona de declarações da função
Tipo_Retorno_Função :: Nome_Função
!Corpo da função
[RETURN]
...
END FUNCTION [Nome_Função]
Invocação e utilização de funções
Nome_Função ( Lista_parâmetros)

FORTRAN
Exemplo (mostra diferentes modos de invocar uma função):

INTEGER :: x = Nome_Função ( ... )
x = Nome_Função ( ... )
PRINT *, Nome_Função ( ... )
Atribuição do resultado da função

Exemplo:
PROGRAM Exemplo
IMPLICIT NONE
REAL :: a
PRINT *, Soma(10., 20.)
a = Soma(10., 20.)
PRINT *, a
CONTAINS
REAL FUNCTION Soma(x, y)
REAL, INTENT(IN) :: x, y
Soma = x + y
END FUNCTION
END
Funções como parâmetros

É ainda possível utilizar funções como parâmetros de outras funções ou
subrotinas:
PROGRAM Exemplo
IMPLICIT NONE
PRINT *, maior(maior(10., 20.), 15.)

FORTRAN
CONTAINS
REAL FUNCTION maior(x,y)
REAL, INTENT(IN) :: x, y
IF (x > y) THEN
maior = x
ELSE
maior = y
END IF
END FUNCTION
END
Procedimentos recursivos
Em determinadas situações pode ser útil que um procedimento se

reutilize a si próprio, ou seja, um determinado procedimento invocar-se a si
próprio. Este tipo de procedimentos designam-se por recursivos.
Declaração de subrotinas recursivas
RECURSIVE SUBROUTINE
Nome_Subrotina(Lista_parâmetros)
...
END SUBROUTINE [Nome_Subrotina]
Declaração de funções recursivas
RECURSIVE FUNCTION Nome_função(Lista_parâmetros) RESULT(Resposta)

...

FORTRAN
END FUNCTION [Nome_função]

O RESULT permite atribuir um nome ao resultado da função para que
não exista conflito entre a função que invoca e a função que é invocada, como
se mostra no exemplo seguinte. A utilização desta instrução é obrigatória, isto
é, caso não seja utilizada o programa incorre num erro de compilação.
Suponha que se pretende implementar uma função recursiva que permita

calcular a soma dos n números compreendidos entre 1 e n.
RECURSIVE FUNCTION soma(n) RESULT(total)

INTEGER, INTENT(IN) :: n
INTEGER :: total
IF(n > 0) THEN
total = n + soma(n-1)
ELSE
total = 0
END IF
END FUNCTION
A resolução do problema anterior, mas agora recorrendo a uma subrotina

recursiva:
RECURSIVE SUBROUTINE soma(n, t)
INTEGER, INTENT(IN) :: n
INTEGER, INTENT(OUT) :: t
IF(n > 0) THEN
CALL soma(n-1, t)
t=t+n
ELSE

FORTRAN
t=0
END IF
END SUBROUTINE
Ordem dos parâmetros
O Fortran permite, aquando da invocação dos procedimentos, que se

altere a ordem pela qual os parâmetros estão dispostos, desde que para tal se
utilize o nome dos mesmos. Exemplo:
MODULE exemplo
CONTAINS
REAL FUNCTION calculo(pri, seg, ter)
IMPLICIT NONE
REAL, INTENT(IN) :: pri, seg, ter
calculo = (pri - seg) / ter
END FUNCTION
END MODULE exemplo
PROGRAM teste
USE exemplo
IMPLICIT NONE
WRITE (*,*), calculo(3., 2., 1.)
WRITE (*,*), calculo(pri = 3., seg = 2., ter = 1.)
WRITE (*,*), calculo(ter = 1., seg = 2., pri = 3.)
END PROGRAM

FORTRAN
Parâmetros opcionais
O Fortran 90/95 admite a utilização de parâmetros opcionais, isto é,

parâmetros que podem ou não ser incluídos aquando da invocação do
procedimento. Para tal a interface do procedimento deve ser declarada
explicitamente, o que equivale a implementar o procedimento num módulo ou
importar a partir deste último a interface.
Os procedimentos cuja interface é declarada explicitamente permitem
ainda que se utilize os parâmetros pelos nomes (e não apenas pela ordem que
são declarados).
[CALL] Nome_Procedimento ( Nome_parâmetro = expressão, ...)
Declaração
Para se declarar os parâmetros como opcionais utiliza-se o atributo
OPTIONAL.
Tipo, INTENT(IN|OUT|INOUT), OPTIONAL :: Lista_parâmetros
Exemplo:
SUBROUTINE teste(a, b, c)
REAL, INTENT(IN), OPTIONAL :: c
...
END SUBROUTINE
Detectar a existência de parâmetros

FORTRAN
Como um parâmetro pode ser declarado opcional, é legítimo perguntar:

Como é que se sabe se o parâmetro vai estar ou não presente aquando da
invocação do procedimento?
Para tal existe a função intrínseca PRESENT:
LOGICAL PRESENT(Parâmetro_opcional)
que devolve verdadeiro (.TRUE.) se o parâmetro estiver presente.
Exemplo:
MODULE exemplo
CONTAINS
REAL FUNCTION media(a,b,c)
REAL, INTENT(IN), OPTIONAL :: c
IF (PRESENT(c)) THEN
media = (a + b + c) / 3
ELSE
media = (a + b) / 2
END IF
END FUNCTION
END MODULE
PROGRAM teste
USE exemplo
WRITE (*,*) media(10., 20., 30.)
WRITE (*,*) media(20., 30.)
WRITE (*,*) media(b=20., a=10., c=30.)
END PROGRAM

FORTRAN
A técnica dos parâmetros opcionais já era nossa conhecida de algumas

funções intrínsecas, como por exemplo o SELECT_REAL_KIND. A seguir
apresentamos alguns exemplos com a utilização desta função:
kind = SELECT_REAL_KIND(12, 100)
kind = SELECT_REAL_KIND(12)
kind = SELECT_REAL_KIND(r = 100, p = 13)
kind = SELECT_REAL_KIND(p = 13)
Note-se que a sintaxe desta função é a seguinte:

SELECT_REAL_KIND([p][,r])
Esta função devolve o tipo de valor para uma precisão específica (por exemplo
quando temos o parâmetro p = 13, isto significa que o valor irá ter 13 casas
decimais, ao passo que o parâmetro r permite especificar a precisão do
expoente).
1) Implemente uma função em que dado um array determina e devolve o valor

médio dos seus elementos.
2) Implemente um procedimento em que dados dois arrays com a mesma

dimensão e estrutura, devolve um terceiro array em que cada elemento
corresponde ao maior valor para a respectiva posição dos arrays de entrada.
3) Implemente uma função em que dados os coeficientes de uma equação de

segundo grau, devolve as respectivas raízes.
4) Implemente uma função que calcule o factorial de um dado valor inteiro.

FORTRAN
5) Implemente uma função em que dados dois, três, ou quatro inteiros, devolva
o maior.
Processamento de ficheiros
WRITE
WRITE (control_list) output_list
control_list:
UNIT = unit_specifier ! Inteiro que identifica o ficheiro;
FMT = format_specifier ! É o formato segundo o qual se pretende
! aceder aos dados;
ADVANCE = character_expression ! Permite inserir, ou não, o
! new line após imprimir os argumentos da output_list.
“No” ! Não insere o new line
“Yes” ! Insere o new line (valor por defeito)
Exemplos:
WRITE (UNIT = 6, fmt = *) “Olá bom dia”
WRITE (6, *) “Olá bom dia”
WRITE (*, *) “Olá bom dia” PRINT *, “Olá bom dia”
WRITE (*,”(a)”, ADVANCE=”YES”) “Insira um valor”
READ *,valor
> Insira um valor
> 10
WRITE (*,”(a)”, ADVANCE=”NO”) “Insira um valor”

READ *,valor

FORTRAN
> Insira um valor10
READ
READ (control_list) input_list
control_list:
UNIT = unit_specifier ! Inteiro que identifica o ficheiro;
FMT = format_specifier ! É o formato segundo o qual se pretende
! aceder aos dados;
ADVANCE = character_expression ! Permite acrescentar à lista
de entrada o caracter new line.
“No” ! Não insere o new line
“Yes” ! Insere o new line (valor por defeito)
IOSTAT = Variável_inteira
! Permite detectar a ocorrência de erros durante a operação.
Variável_inteira = 0 ! Operação bem sucedida.
Variável_inteira > 0 ! Ocorrência de erro.
Variável_inteira < 0 ! Operação bem sucedida
! tendo sido alcançado o fim do ficheiro.
END = Label
! Em caso de erro a execução continua na instrução identificada pela Label.
Exemplo:
READ (*,*) Largura, Altura
READ (*, FMT =*) Largura, Altura
READ (UNIT=*, IOSTAT=Erro, END=100) Largura, Altura
100 PRINT *,”Erro de acesso do teclado”

FORTRAN
Acesso a um ficheiro
Ciclo de Operações:
Abrir Ficheiro
Ler/Escrever de/no ficheiro
Fechar Ficheiro
OPEN (...)
READ (...) ... / WRITE(...) ...
CLOSE
OPEN
OPEN (Lista_controlo)
Lista_controlo:
Identificador do ficheiro:
UNIT = constante_inteira/variável_inteira
Nome do ficheiro:
FILE = constante_string/variável_string
Modo de criar/abrir um ficheiro:
STATUS = constante_string/variável_string
“OLD” ! Abre um ficheiro que já existe.
“NEW” ! Cria e abre um novo ficheiro.
“REPLACE” ! Se o ficheiro não existir, cria e abre um novo
ficheiro, caso contrário substitui o actual ficheiro e abre.

FORTRAN
“SCRATCH” ! Permite criar um ficheiro temporário. Não deve ser

utilizado em simultâneo com FILE.
“UNKNOWN” ! Valor utilizado por defeito e quando se desconhece a
situação do ficheiro.
Modo de acesso:
ACESS = constante_string/variável_string
“SEQUENTIAL” ! A leitura/escrita é feita de modo
sequencial. É o valor por defeito desta opção.
“DIRECT” ! A leitura/escrita é feita em modo directo.
Finalidade do acesso:
ACTION = constante_string/variável_string
“READ” ! Abre o ficheiro para leitura
“WRITE” ! Abre o ficheiro para escrita
“READWRITE” ! Abre o ficheiro para leitura e escrita
Posição inicial no ficheiro:

POSITION = constante_string/variável_string
“REWIND” ! Abre e coloca-se no início do ficheiro.
“APPEND” ! Abre e coloca-se no fim do ficheiro.
Tratamento de erros:
IOSTAT = Variável_inteira
Variável_inteira = 0 ! Operação bem sucedida.
Variável_inteira > 0 ! Ocorrência de erro.
Variável_inteira < 0 ! Operação bem sucedida, tendo sido alcançado
o fim do ficheiro.

FORTRAN
Tratamento dos espaços em branco:

BLANK = constante_string/variável_string
“ZERO” ! Nos campos do tipo numérico, os espaços são
interpretados como zeros.
“NULL” ! Nos campos do tipo numérico, os espaços são
ignorados.
Execução de instruções em caso de erro:

ERR = label
Se o ficheiro é ou não formatado:

FORM = constante_string/variável_string
“FORMATTED” ! Formatado (texto).
“UNFORMATTED” ! Não formatado.
Tamanho de um record em acesso directo:

RECL = constante_inteira/variável_inteira
Exemplos:
INTEGER :: erroescrita, erroleitura
CHARACTER(30) :: ficheiro
PRINT *, “Nome do ficheiro?”
READ *, ficheiro
OPEN(UNIT=20, FILE=ficheiro, STATUS=”REPLACE”, ACTION=”WRITE”, IOSTAT=erroescrita)
IF (erroescrita > 0) THEN

PRINT *, “Não foi possível aceder ao ficheiro para escrita”
OPEN(UNIT=20, FILE=”Dados.bin”, STATUS=”OLD”, ACTION=”READ”, IOSTAT=erroleitura)
IF (erroleitura > 0) THEN

PRINT *, “Não foi possível aceder ao ficheiro para leitura”

FORTRAN
...
CLOSE
Instrução CLOSE permite “fechar” um ficheiro.
CLOSE (Lista_controlo)
Identificador do ficheiro:
UNIT = constante_inteira/variável_inteira
Pode ainda incluir os seguintes parâmetros:

IOSTAT ! Semelhante ao da instrução OPEN
ERR ! Semelhante ao da instrução OPEN
Modo de fechar o ficheiro:

STATUS = constante_string/variável_string
“KEEP” ! Mantém o ficheiro após fechar.
“DELETE” ! Apaga o ficheiro após fechar.
Exemplos:
CLOSE (UNIT=30, STATUS=”KEEP”)
CLOSE (30, ERR=200, STATUS=”DELETE”)
INQUIRE
Permite interrogar o sistema operativo sobre determinado ficheiro.
INQUIRE (UNIT = inteiro/var_inteira, Lista_controlo)
INQUIRE (FILE = nome_fich, Lista_controlo)

FORTRAN
A lista de controlo aceita os seguintes parâmetros:

ACCESS = variável_string
“SEQUENTIAL” ! Indica que o ficheiro foi aberto em
modo sequencial
“DIRECT” ! Indica que o ficheiro foi aberto em
modo directo.
“UNDEFINED” ! Indica que o ficheiro não foi aberto.
ACTION = variável_string
“READ” ! Ficheiro aberto em modo leitura
“WRITE” ! Ficheiro aberto em modo escrita
“READWRITE” ! Ficheiro aberto em modo leitura e escrita
“UNDEFINED” ! Ficheiro não aberto
READ = variável_string
! Permite determinar se o ficheiro foi aberto para leitura.
WRITE = variável_string
! Permite determinar se o ficheiro foi aberto para escrita.
READWRITE = variável_string
! Permite determinar se o ficheiro foi aberto para leitura e escrita.
“YES” ! Sinal de afirmativo
“NO” ! Sinal de negativo
“UNKNOWN” ! Ficheiro não aberto
BLANK = variável_string
“ZERO” ! Que os espaços, nos campos tipo
numérico, são tratados como zeros.

FORTRAN
“NULL” ! Que os espaços, nos campos tipo

numérico, são tratados nulos.
“UNDEFINED” ! Ficheiro não aberto.
ERR = label
No caso de ocorrer erro na execução do INQUIRE, a execução do
programa continua na instrução associada à label.
EXIST = variável_lógica
Permite verificar a existência de um ficheiro.
.TRUE. ! Caso o ficheiro exista
.FALSE. ! Caso o ficheiro não exista
FORM = variável_string
Permite determinar se o ficheiro está ou não formatado.
“FORMATTED” ! Formatado
“UNFORMATTED” ! Não formatado
“UNDEFINED” ! Ficheiro não aberto
IOSTAT = variável_inteira
Permite detectar a ocorrência de erros aquando da execução do
INQUIRE.
NAME = variável_string
Permite determinar o nome do ficheiro com base no UNIT.
Devolve o nome do ficheiro se este existir;
Caso contrário devolve “UNDEFINED”.
NAMED = variável_lógica

FORTRAN
Permite determinar se o ficheiro possui um nome.

.TRUE. ! Se o ficheiro possuir nome
.FALSE. ! Se o ficheiro não possuir nome
NEXTREC = variável_inteira
Devolve a posição do próximo registo a ser lido.
NUMBER = variável_inteira
Permite com base no nome, determinar o UNIT do ficheiro.
Se o ficheiro existir, devolve o respectivo UNIT;
Caso contrário, devolve –1.
OPENED = variável_lógica
Permite determinar se um ficheiro está, ou não, aberto.
.TRUE. ! Se o ficheiro está aberto
.FALSE. ! Se o ficheiro está fechado
REWIND
Posiciona o acesso do ficheiro no início deste.
REWIND identificador_ficheiro
BACKSPACE
Em ficheiros abertos em modo formatado, permite retornar ao início da
linha anterior.
BACKSPACE identificador_ficheiro
ENDFILE
Escreve o caracter de fim de ficheiro (no ficheiro) e posiciona-se após
este.

FORTRAN
ENDFILE identificador_ficheiro

Sebenta

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Sebenta

Enviado por

Direitos autorais:

Formatos disponíveis

Escola Superior de

Ano Lectivo de 2002/2003

Fornecer aos alunos conhecimentos necessários ao desenvolvimento

Sistema de avaliação para 2002/2003

Avaliação Época Normal (1ª e 2ª Chamadas) e de Recurso

Fichas de avaliação 20%

As fichas de avaliação serão realizadas durante as aulas teóricas e práticas,

Avaliação para a Época Especial

Fórmula de cálculo da nota final com fichas de avaliação

Fórmula de cálculo da nota final sem fichas de avaliação

INTRODUÇÃO À RESOLUÇÃO ALGORÍTMICA DE PROBLEMAS

S. Chapman, “Fortran 90/95 – For Scientists and Engineers”,

L. Nyhoff, S. Leestma, “Fortran 90 – For Engineers and

W. Schick, G. Silverman, “Fortran 90 and Engineering

Computation”, Jonh Wiley & Sons.

I. M. Smith, “Programming in Fortran 90 – A first Course for

Engineers and Scientists”, Jonh Wiley & Sons.

T. M. R. Ellis, I. R. Philips, T. M. Lahey, “Fortran 90

L. Alves, P. Matos, “Textos de Apoio de Algoritmia e

L. Alves, “Caderno de Exercícios de Algoritmia e Fortran”.

INTRODUÇÃO À RESOLUÇÃO ALGORÍTMICA DE

É uma forma de descrição suficientemente abstracta para que não se

A concepção de um algoritmo, deve ser entendida como parte de todo

Após a concepção do algoritmo há que avaliar tão exaustivamente

Posteriormente vem a implementação que, dentro do contexto desta

O processo termina após se verificar que tudo funciona como

O processo começa por uma análise mais ou menos detalhada do

Posteriormente analisa-se cada uma dessas componentes, descrevendo

No nosso quotidiano deparamo-nos frequentemente com exemplos de

Exemplo: Substituição de uma lâmpada

Agora vejamos o algoritmo para a substituição de uma lâmpada sem

Componentes básicas da solução

De forma a tornar mais perceptíveis todas estas acções a quem não

Garantir a segurança da operação

Arranjar e posicionar um meio de aceder à lâmpada

Colocar a nova lâmpada

Testar se a nova lâmpada funciona

Arrumar os meios despendidos na operação

Solução com situações condicionais/repetição

Garantir a segurança da operação

Arranjar e posicionar um meio de aceder à lâmpada

Colocar a nova lâmpada

Arrumar os meios despendidos na operação

Colocar a nova lâmpada Colocar a nova lâmpada

Vejamos agora outro algoritmo para resolução de equações de 2º

Exemplo: Cálculo das raízes de uma equação de 2ª ordem

Uma primeira abordagem para a resolução do problema, pode ser

Componentes básicas da solução

No entanto, esta solução ainda é demasiado geral, pelo que devemos

Como sabemos, mediante o cálculo de b 2 4 * a * c podemos ter duas raízes

Na primeira situação, existem duas raízes reais diferentes x1 e x 2 , na

Ler o valor de a,b e c

Estrutura sequencial de operações

Estrutura sequencial com operações de Entrada

Estrutura sequencial com operações de Saída

Início ou fim do algoritmo

Estrutura condicional, do tipo:

Ponto de convergência de mais do que uma

Ler o valor de a, b e c Início

Se b 2 4 * a * c > 0 então Ler

Elementos de uma descrição

Decomposição do problema por módulos

Uma boa prática de programação consiste em subdividir o programa

sua invocação para as utilizar. No entanto, quando pretendemos tarefas