Fortran 90

Disciplina: Métodos Computacionais / 1º Semestre de 2005
Parte 1 – Conceitos Fundamentais da Linguagem Fortran – Versão F90
1. Introdução 1
2. Linguagens de Programação 1
3. Uso da Linguagem Fortran em Computadores 3
4. Formatação de um Programa em Fortran 3
5. Estrutura de um Programa em Fortran 4
6. Constantes e Variáveis 5
6.1 Declaração de Constantes e Variáveis 6
6.2 Inicialização de Valores de Variáveis 6
6.3 Programa com Diferentes Tipos de Variáveis 7
7. Leitura e Impressão de Dados em Arquivo Externo 8
8. Comentários 9
9. Formatação de Dados de Entrada e Saída 9
10. Funções Internas 11
11. Expressões Aritméticas e Lógicas 11
11.1 Exemplos 12
12. Comandos IF e DO 12
13. Sub-rotinas e Funções 13
14. Arranjos ou Variáveis Compostas 14
14.1 Dimensionamento Dinâmico de Arranjos 15
14.2 Operações com Arranjos em F90 15
Anexo – Lista de Programas 16
Referências Bibliográficas 35
Autor: Renato César Gavazza Menin

Brasília, 22 de Março de 2005
Métodos Computacionais / 1º Semestre de 2005 1
1. Introdução:
• Solução Analítica.
• Laboratório.
• Computador.
Forma Vantagens Desvantagens

Sol. Analítica Resposta exata. Necessário fazer simplificações ( linearizações,
Visualização de todo o processo. homogeneização de materiais, simetrias ...).
Inviável para problemas complexos (tempo).
Laboratório Realismo. Disponibilidade e custos de materiais,
equipamentos e mão de obra).
Necessidade de grande quantidade de ensaios.
Computador Sem simplificações. Uso de softwares não confiáveis.
Rapidez, relativamente barato. Análise inadequada de resultados.
2. Linguagens de Programação:
Os programadores escrevem instruções em várias linguagens de programação, algumas

entendidas diretamente pelo computador e outras que exigem passos intermediários de
tradução. Centenas de linguagens computacionais estão atualmente em uso. Estas podem ser
divididas em três tipos gerais:
• Linguagens de máquina.
• Linguagens assembly.
• Linguagens de alto nível.
Qualquer computador pode entender apenas a sua própria linguagem de máquina, que está
relacionada intimamente com o seu projeto de hardware. Geralmente as linguagens de
máquina consistem em strings de números (reduzidos em última análise de 1s e 0s) que dizem
ao computador para realizar uma de suas operações mais elementares de cada vez. As
linguagens de máquina são dependentes da máquina (não padronizadas), ou seja, uma
determinada linguagem de máquina só pode ser usada com um tipo de computador. As
linguagens de máquina são complicadas para os humanos, como se pode ver no trecho de um
programa em linguagem de máquina extraído de Deitel & Deitel [1994], que adiciona o
Termo_B ao Termo_A e armazena o resultado no Termo_C.
+1300042774
+1400593419 : linguagem de máquina
+1200274027
À medida que os computadores se tornaram mais populares, ficou claro que a programação
em linguagem de máquina era muito lenta e tediosa para a maioria dos programadores. Em
vez de usar strings de números que os computadores podiam entender diretamente, os
programadores começaram a usar abreviações parecidas com palavras em inglês para
representar as operações elementares de um computador. Estas abreviações formam a base
das linguagens assembly. Foram desenvolvidos programas tradutores, chamados assemblers,
para converter programas de linguagem assembly para linguagem de máquina. O trecho de
um programa em linguagem assembly a seguir, extraído de Deitel & Deitel [1994], também
adiciona o Termo_B ao Termo_A e armazena o resultado no Termo_C, porém isto é feito de

uma forma mais clara que o programa equivalente em linguagem de máquina.
LOAD Termo_A
ADD Termo_B : linguagem assembly
STORE Termo_C
O uso do computador aumentou rapidamente com o advento das linguagens assembly,

mais elas ainda exigiam muitas instruções para realizar mesmo as tarefas mais simples. Para
acelerar o processo de programação, foram desenvolvidas linguagens de alto nível, nas quais
podiam ser escritas instruções simples para realizar tarefas fundamentais. Os programas
tradutores que convertiam linguagens de alto nível em linguagem de máquina são chamados
compiladores. As linguagens de alto nível permitem aos programadores escrever instruções
que se parecem com o idioma inglês comum e contém as notações matemáticas normalmente
usadas. O mesmo trecho de programa comentado acima pode se escrito em uma linguagem
de alto nível da seguinte forma:
Termo_C = Termo_A + Termo_B : linguagem de alto nível
Obviamente, as linguagens de alto nível são muito mais desejáveis do ponto de vista do
programador do que as linguagens de máquina ou assembly. Dentre as linguagens de
computador de alto nível mais comuns hoje em dia, destacam-se: Ada, Basic, Cobol, C, C++,
Delphi, Fortran e Pascal. Destas linguagens, o Fortran tem sido uma das linguagens mais
utilizadas nos últimos cinqüenta anos para cálculos científicos em geral, tendo sido
empregada para uma grande variedade de aplicações: modelos computacionais de centrais
nucleares, projetos de aeronaves, sistemas de processamento de sinais sísmicos, programação
em supercomputadores, computação paralela de grande porte, etc...
A linguagem Fortran foi a primeira linguagem de alto nível usada para programação de
computadores. Foi proposta em 1953 por J. Backus, mas o seu primeiro compilador, feito
para o computador IBM 704, só foi liberado em 1957. Seu nome é formado pelas letras
iniciais das palavras FORmula TRANslation, que indicam sua principal inovação na época: a
facilidade de transcrição de fórmulas matemáticas para serem usadas em computadores.
Posteriormente, numerosos aperfeiçoamentos foram introduzidos em novas versões, sendo
principais as denominadas Fortran II (1958), Fortran IV (1961), Fortran 66 (1966) e o
Fortran 77 (1977), o qual resultou de um esforço para modernizar as versões anteriores e
formar um padrão que foi aprovado pelo American National Standards Institute (ANSI).
Dentre as modernizações destacam-se a introdução de estruturas de controle, (bloco IF) e
facilidades na manipulação de variáveis literais.
A próxima grande atualização da linguagem foi representada pelo Fortran 90. Dentre os
avanços do Fortran 90 podem-se destacar: new free source format (na versão Fortran 77, as
colunas 1 a 5 deveriam conter o número do comando ou declaração, quando usado, a coluna 6
era usada para indicar a continuação da linha anterior e os comandos deveriam estar
compreendidos entre as colunas 7 a 72 ao passo que na versão Fortran 90, pode-se iniciar a
digitação dos comandos na coluna 1); facilidades na criação e operações de manipulação de
arrays (vetores e matrizes); interfaces mais amigáveis; etc...
Nas próximas seções serão apresentadas algumas estruturas, palavras chaves, comandos de
atribuição, comandos de entrada e saída de dados, ferramentas para modularização (subrotinas
e funções) e aspectos em geral para construção de programas na linguagem Fortran, dando-se
ênfase à versão F90, porém fazendo uma analogia à versão F77 quando necessário.
3. Uso da Linguagem Fortran em Computadores:
A utilização da linguagem Fortran para resolver um problema em um computador faz-se,

como em outras linguagens de programação, através de sucessivas fases:
• Definição do Problema. É a descrição e a delimitação do problema a ser resolvido,

caracterizando-o de maneira clara e completa.
• Desenvolvimento de um Algoritmo. Objetiva a descrição, geralmente desenvolvida
por etapas (refinamentos), do processamento a ser realizado para resolver o problema
e obter os resultados desejados no computador.
• Transcrição do algoritmo para a Linguagem Fortran. Objetiva a obtenção de um
programa equivalente, de acordo com as regras e recursos oferecidos pela linguagem.
• Processamento do Programa pelo Computador. Obedecendo a um programa
denominado compilador da linguagem Fortran, o computador verifica a correção
sintática do programa que lhe é apresentado e o traduz para um novo programa em
linguagem de máquina. Em seguida este novo programa é executado e passa a
controlar o computador através das suas instruções, fazendo a resolução do problema e
obtendo os resultados desejados.
Programa Fonte
⇓ ( Compilador )
Programa Objeto + Biblioteca
⇓ ( Linkagem )
Programa Executável
⇓ ( Execução )
Resultados
• Análise de Resultados. Os resultados obtidos pelas primeiras execuções de um

programa num computador devem ser cuidadosamente analisados, pois eles podem
estar parcial ou totalmente comprometidos com erros cometidos nas quatro primeiras
fases. Se houver erro, será necessário retornar à fase correspondente, fazer as devidas
correções e repassar as fases seguintes.
4. Formatação de um programa em Fortran:
O texto de um programa em Fortran 77 deve ficar disposto em linhas. As linhas devem

ter 80 colunas, e cada coluna só pode conter um caractere (letra, dígito ou sinal especial). As
colunas 73 a 80 não são analisadas pelo compilador e geralmente são deixadas em branco.
Antigamente, quando os programas eram digitados em cartões perfurados (cada linha em um
cartão), estas colunas eram usadas para numerar os cartões e facilitar a sua reordenação caso
acidentalmente ficassem desordenados.
Cada linha de um programa pode conter um comentário, uma declaração ou um comando.
Se a linha contiver um comentário, a coluna 1 deve ter a letra C, e as colunas 2 a 72, os
dizeres do comentário. Se a linha contiver um comando ou uma declaração, as colunas
devem ser agrupadas da seguinte maneira:
• colunas 1 a 5 para conter o número do comando ou da declaração (label ou rótulo),

quando usado;
• coluna 6 para indicar continuação da linha anterior;
• colunas 7 a 72 para conter o comando ou a declaração.
Um comando ou declaração pode continuar nas colunas 7 a 72 de várias linhas

consecutivas que contiverem na coluna 6, caractere diferente de zero e de espaço em branco.
Neste caso, a coluna 7 de uma linha de continuação é considerada como sucessora da coluna
72 da linha anterior.
No caso do Fortran 90, graças ao chamado free source format, conforme comentado
anteriormente, os comandos e declarações podem ser digitados em qualquer lugar de uma
linha e cada linha pode receber até 132 caracteres. Caso um comando ou declaração seja
muito longo e não caiba em uma única linha, pode-se continuar na linha seguinte digitando-se
o símbolo & (ampersand) no final da linha corrente. Por exemplo, os seguintes comandos são
idênticos:
Output = input1 + input2
Output = input1 &

+ input2
Vale ressaltar que tanto no Fortran 77 quanto no Fortran 90, os espaços em branco são
irrelevantes e ignorados pelo programa compilador. Eles são considerados apenas nas
constantes literais.
5. Estrutura de um Programa em Fortran:
Cada programa em Fortran consiste de um agrupamento de declarações executáveis e não

executáveis, que devem ocorrer em uma ordem específica. Um programa simples em F90 é
mostrado a seguir, no qual dois números inteiros são lidos digitando-se os números através do
teclado e em seguida é efetuada a multiplicação de um pelo outro e a impressão do resultado
da multiplicação dos números na tela do computador:
Estrutura de um Programa Simples: Program exercise_1
* Nome ! Purpose:
* Declarações (não executáveis) ! To illustrate some of the basic features of a Fortran program.
* Linhas executáveis
* End program ! Declare de variables used in this program:
integer I,J,K
! Read the numbers:

write(*,*) ‘Enter the numbers to multiply: ‘
read (*,*) I,J
! Multiply the numbers:

K = I*J
! Write out the result:

write(*,*) ‘Result = ‘, K
end program
Vale ressaltar que os programas fonte em Fortran escritos na versão F77 devem ter a
extensão “.for” ao passo que os programas fonte escritos na versão F90 devem possuir uma
extensão “.f90”. É através da extensão que o compilador reconhece em que versão o
programa fonte foi escrito. O compilador não aceitará o free source format se o arquivo
fonte for definido com a extensão “.for”.
6. Constantes e Variáveis:
As constantes, conforme o próprio nome diz, são entidades cujos valores são fixos ao
longo de todo o programa, não sendo possível alterar os seus valores durante a execução,
sendo declaradas através do comando parameter. Já as variáveis podem sofrer alterações ao
longo da execução do programa. A cada variável corresponde uma posição de memória, cujo
conteúdo pode variar ao longo do tempo, durante a execução do programa. Embora uma
variável possa assumir diferentes valores, ela só pode armazenar um valor a cada instante.
Toda constante ou variável é identificada por um nome ou identificador, cuja formação
obedece a determinadas regras:
• F77: identificador pode ter no máximo 6 caracteres.

• F90: identificador pode ter até 31 caracteres.
• Os identificadores não são case sensitive, ou seja, letras maiúsculas e minúsculas são
consideradas iguais pelo compilador: variable_1 = Variable_1 = VARIABLE_1.
• O primeiro caractere de um identificador deve, obrigatoriamente, ser uma letra e os
demais, letras ou números, não sendo permitido o uso de símbolos especiais:
9 26 letras do alfabeto (a,b,c,d,...,w,x,y,z)

9 10 números (0,1,2,3,..., 8,9)
9 barra inferior ( _ )
Exemplo:
1. Identificadores permitidos:
Nota, total, A, X5, Var1, A32B, F1G3H5, step_1,...
2. Identificadores não permitidos:
5B : começa pelo dígito 5
E(13) : contém os caracteres especiais ( )
A:B : contém o caractere especial :
Var A : contém espaço em branco
Var–A : contém o caractere especial – .
Observação: Não confundir o caractere “_ “ com o caractere “–“.
Conforme o seu tipo, as constantes e variáveis podem ser classificadas como numéricas
(inteiras ou reais), lógicas ou literais, entre outras.
1. Integer: 9 armazena em forma exata até o limite, sem parte decimal.

9 intervalo válido: [ -2147483648, +2147483647 ].
9 exemplos: 1000, 0, 1, -1, 999,...
2. Real: 9 números reais, ou seja, com parte decimal em precisão simples.

9 número de dígitos na mantissa: 6
9 intervalo válido: [1.0e+38, 1.0e-37], positivo ou negativo.
9 exemplos: 1.5, -0.01, 37., -6.8543, -1.0e-2, ...
3. Real*8: 9 números reais, ou seja, com parte decimal em precisão dupla.

9 número de dígitos na mantissa: 15
9 intervalo válido: [1.0e+308, 1.0e-307], positivo ou negativo.
9 exemplos: 1.5000, -0.0001, 37., -6.8543, -1.0e-2, ...
4. Logical: 9 é um valor lógico, que só pode ser verdadeiro ou falso, usado em

proposições lógicas.
9 só existem duas constantes deste tipo, sendo representadas pelas
palavras true e false, precedidas e seguidas por ponto decimal,
.true. e .false..
5. Character: 9 constante literal que representa qualquer seqüência de caracteres.

9 a seqüência de caracteres, também conhecida por string, deve estar
entre apóstrofos.
9 número máximo de caracteres = [255].
9 exemplos: ‘Met_Computacionais’, ‘Resultado : ‘, ‘A5%(x): ‘,...
6.1 Declaração de Constantes e Variáveis:
No F77 havia uma regra de declaração implícita de variáveis, segundo a qual qualquer
variável que começasse com as letras (I, J, K, L, M, N) representavam variáveis inteiras
(integer) e todas as variáveis que começassem com outra letra diferente destas representavam
variáveis reais (real), a não ser que se declarasse diferente, de forma explícita. Desta forma
obtém-se declarando a variável inteira Juro1 de forma implícita e a variável real Juro2 de
forma explícita:
Real Juro2
Juro1 = 0.09 ! Resultado: Juro1 = 0 (integer)
Juro2 = 0.09 ! Resultado: Juro2 = 0.09 (real)
Embora seja permitido este tipo de declaração implícita, para maior clareza do programa é
aconselhável que as variáveis sejam declaradas explicitamente, o que pode ser feito da
seguinte forma, conforme o tipo de variável:
integer var1, var2 ! declaração de variáveis do tipo inteiro.

real var3, var4 ! declaração de variáveis do tipo real com precisão simples.
real*8 var5 ! declaração de variáveis do tipo real com precisão dupla.
logical var6,var7 ! declaração de variáveis do tipo lógica.
character*n var8 ! sendo “n” o número máximo de caracteres na variável var8.
Pode-se inibir a declaração implícita com o comando: implicit none, colocado antes da
declaração de variáveis, no início do programa.
6.2 Inicialização de Valores de Variáveis:
a) Explicitar:
Contador = 1
Taxa = 0.09
Word = ‘Met_Computacionais’
b) Utilizando declaração DATA:
DATA A,B,C /1,2,3.1415/ ! Observação: A = 1, B = 2 e C = 3.1415
c) Entrar via teclado (recomendado para pequena quantidade de dados).
d) Leitura de arquivo de entrada de dados (recomendado para grandes volumes).
6.3 Programa com Diferentes Tipos de Variáveis:
Program exercise_2
! Objetivo:
! Ilustrar a utilização de diferentes tipos de variáveis.
! Declaração de variáveis do programa:

integer I,J,K
real var1,var2,var3
real*8 var4
logical flag1,flag2,flag3,flag4,flag5
character*7 const1
character*2 const2
character*9 const3
real*8, parameter :: const_4 = 2500.0 ! Declaração e inicialização de constante
! Inicialização explícita de variáveis:

I = 17
J=4
var1 = 2.000
var2 = 3.000
flag1 = .true.
flag2 = .false.
const1 = ‘Fortran’
const2 = ‘90’
! Operações com variáveis:

K = I/J ! Divisão de inteiro por inteiro = inteiro (arredondamento para baixo)
var3 = var1*var2
var4 = var1*var2
flag3 = flag1.and.flag2
flag4 = flag1.or.flag2
flag5 = .not.flag1
const3 = const1//const2 ! Operação de concatenação de strings
! Imprimir os resultados na tela do computador:

write(*,*) ‘Valor de K = ‘, K
write(*,*) ’Valor de var3 (simple precision) = ‘,var3
write(*,*) ’Valor de var4 (double precision) = ‘,var4
write(*,*) ’Valor de flag3 = ‘,flag3
write(*,*) ‘String const3 = ‘,const3
write(*,*) 'Constante const_4 = ',const_4
end program
Impressão de Resultados na Tela do Computador:
Valor de K = 4
Valor de var3 (simple precision) = 6.000000
Valor de var4 (double precision) = 6.000000000000000
Valor de flag3 =F
Valor de flag4 =T
Valor de flag5 =F
String const3 = Fortran90
Constante const 4 = 2500.000000000000000
7. Leitura e Impressão de Dados em Arquivo Externo:
No caso de uma grande quantidade de dados é sempre interessante a leitura e a impressão

dos mesmos em arquivos externos. Antes de usar um arquivo externo é necessário que o
mesmo seja aberto utilizando-se o comando OPEN. O comando OPEN abre um arquivo
através das seguintes operações: associa o nome externo do arquivo à unidade que será usada
nos comandos de entrada ou saída, e estabelece o atributo de estado do arquivo. A forma do
comando é a seguinte:
Open (Unit = n, File = ‘nome-ext-arquivo’, Status = ‘estado’)
• n: variável ou constante, inteira e não negativa que identifica a unidade de entrada ou

saída;
• nome-ext-arquivo: é o nome externo do arquivo que deve ser colocado entre
apóstrofos ou então o nome de uma variável do tipo character colocada sem
apóstrofos;
• estado: indica o estado do arquivo no momento da abertura. O valor do estado deve
vir entre apóstrofos e pode ser um dos seguintes valores:
9 Old: indica que o arquivo externo já existe (normalmente arquivos de entrada).
9 New: indica que um novo arquivo será criado (normalmente arquivos de saída).
9 Unknown: quando não se sabe o estado do arquivo, podendo ser utilizado para
arquivos de entrada ou saída de dados.
Program exercise_3
! Objetivo: Ilustrar a leitura e impressão de dados em arquivos externos.

integer I,J,K
real var1,var2,var3
character*15 filein, fileout ! nomes dos arquivos de entrada (*.dat) e saída de dados (*.out)
! Abertura de arquivos externos para entrada e saída de dados:

write(*,*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*.dat)
read (*,*) filein
open(unit=10, file=filein, status = ‘unknown’)
write(*,*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*.out)
read (*,*) fileout
open(unit=20, file=fileout, status = ‘unknown’)
! Leitura de Dados do Arquivo de Entrada de Dados:

read(10,*) I,J
read(10,*) var1,var2

K = I+J
var3 = var1 * var2
! Imprimir os resultados na tela do computador:

write(*,*) ‘Valor de K = ‘, K Arquivo de Entrada de Dados / Exercise_3.dat
write(*,*) ’Valor de var3 = ‘,var3 2 3 ! integer I,J
! Imprimir os resultados no arquivo de saída: 5.00 6.00 ! real var1,var2
write(20,*) ‘Valor de K = ‘, K
write(20,*) ’Valor de var3 = ‘,var3 Arquivo de Saída de Dados / Exercise_3.out
Valor de K = 5
end program Valor de var3 = 30.000000
8. Comentários:
O comentário é um texto ou simplesmente uma frase utilizada para melhorar a clareza do

programa. Na versão F77, a linha de comentário deve ter a letra C na primeira coluna e os
dizeres do comentário colocados nas colunas 2 a 72. Na versão F90, para se colocar um
comentário basta utilizar o caractere ! em qualquer coluna e colocar o comentário logo após o
caractere que o compilador irá desconsiderar qualquer texto colocado desde o símbolo ! até o
final da linha.
9. Formatação de Dados de Entrada ou Saída:
Na linguagem Fortran, é através da especificação format, que é descrito como os dados

estão dispostos em um meio de entrada e como eles deverão ser distribuídos em um meio de
saída. Sua forma geral é dada por:
read(u,n) lista-de-identificadores
write(u,n) lista-de-identificadores
n format(especificação-de-edição)
• u: é uma constante positiva ou variável contendo um valor inteiro positivo, que

especifica qual a unidade de entrada ou saída que será utilizada.
• n: é um número também chamado de rótulo ou label da especificação format, a qual
indica como os dados encontram-se distribuídos em um meio de entrada ou como eles
devem aparecer em um meio de saída de dados.
• lista-de-indentificadores: são os nomes das variáveis, separados por vírgulas, nas
quais serão armazenados os valores provenientes do meio de entrada ou cujos
conteúdos serão mostrados através do meio de saída.
• especificação-de-edição: é um conjunto de informações sobre a distribuição dos
dados em um meio de entrada/saída, conforme pode ser visto na tabela abaixo sendo w
o tamanho total do campo de entrada/saída.
Vale ressaltar que caso seja digitado o caractere asterisco na unidade de entrada do
comando read ou na unidade de saída do comando write, ou seja (u = *), isto significa que os
dados de entrada (read) e de saída (write) são respectivamente lidos e impressos na tela do
computador, não sendo utilizados arquivos externos de entrada ou saída de dados.
No caso do rótulo da especificação format ser definido com o símbolo asterisco (n = *),
não é necessário colocar o formato da entrada ou saída de dados, uma vez que os mesmos
serão lidos ou impressos em formato livre.
Recomenda-se que não seja utilizada formatação nos arquivos de entrada, uma vez que isto
pode ocasionar a leitura de dados de forma inadequada por um usuário desavisado.
Em um campo de saída, os números aparecem sempre alinhados à direita. Se o número for
negativo, um sinal “–“ é colocado antes do número e se o número for positivo, nenhum sinal é
colocado antes do número. Se o valor de um dado de saída precisar de mais posições do que
as previstas no formato, este será preenchido com asteriscos.
Especificação Tipo de Variável Observação

Iw integer Entrada ou saída de inteiros
Fw.d real Notação cientifica (d = parte decimal)
Ew.d real Notação exponencial (d = parte decimal)
Aw character Entrada ou saída de caracteres
wX ------- Espaços em branco
/ ------- Pular para linha seguinte
Program exercise_4
! Objetivo: Ilustrar a formatação de dados de saída

integer I,J,K
real var1,var2,var3
character*7 programa
character*15 filein, fileout ! nomes dos arquivos de entrada (*.dat) e saída de dados (*.out)
! Abertura de arquivos externos para entrada e saída de dados:

write(*,*)’Input File Name ? (Max 15 Char)’ ! digitar a extensão do arquivo (*.dat)
read (*,*) filein
open(unit=10, file=filein, status = ‘unknown’)
write(*,*)’Output File Name ? (Max 15 Char) ’ ! digitar a extensão do arquivo (*.out)
read (*,*) fileout
open(unit=20, file=fileout, status = ‘unknown’)
! Leitura de Dados do Arquivo de Entrada de Dados:

read(10,*) I,J ! Dados de entrada não formatados
read(10,*) var1,var2
read(10,*) programa

K = I+J
var3 = var1 * var2
! Imprimir os resultados no arquivo de saída sem formatação:

write(20,*) ‘Imprimir Resultados – no format: ‘
write(20,*) ‘Valor de K = ‘, K
write(20,*) ’Valor de var3 = ‘,var3
write(20,*) ’Nome do programa = ‘,programa
! Imprimir os resultados no arquivo de saída com formatação:

write(20,25)
25 format(//‘ Imprimir Resultados – format: ‘)
write(20,30) K
30 format(‘Valor de K = ‘,2x,I8)
write(20,40) var3,var3
40 format(‘Valor de var3 =’,2x,F8.2,/, ‘Valor de var3 =’,2x,E8.2)
write(20,50) programa
50 format(‘Nome do programa =’,A10)
end program
Arquivo de Entrada de Dados / Exercise_4.dat Arquivo de Saída de Dados / Exercise_4.out

10 15 ! integer I,J Imprimir Resultados - no format:
7.00 6.00 ! real var1,var2 Valor de K = 25
Fortran ! character*7 programa Valor de var3 = 42.000000
Nome do programa = Fortran
Imprimir Resultados - format:

Valor de K = 25
Valor de var3 = 42.00
Valor de var3 = .42E+02
Nome do programa = Fortran
10. Funções Internas:
Podem-se usar nas expressões aritméticas algumas funções muito comuns na matemática e
que são supridas pelo compilador Fortran. Na tabela abaixo são apresentadas algumas das
principais funções intrínsecas existentes no Fortran 90:
Função Definição Parâmetro Resultado

----------------------------------------------------------------------------------------------------------
abs(X) valor absoluto de x real/inteiro real/inteiro
-1
acos(X) cos (x) em rad real real
asin(X) sen-1(x) em rad real real
atan(X) tan-1(x) em rad real real
cos(X) cos(x) sendo x em rad real real
sin(X) sen(x) sendo x em rad real real
tan(X) tan(x) sendo x em rad real real
exp(X) ex real real
log(X) loge(x) real real
log10(X) log10(x) real real
mod(X,Y) resto da divisão de X por Y inteiro inteiro
float(X) conversão de inteiro para real inteiro real
sqrt(X) raiz quadrada de x real real
max(X1,...,Xn) seleciona o maior valor Xi real/inteiro real/inteiro
min(X1,...,Xn) seleciona o menor valor Xi real/inteiro real/inteiro
11. Expressões Aritméticas e Lógicas:
Denomina-se expressão aritmética, àquela cujos operadores são aritméticos e cujos

operandos são constantes e/ou variáveis numéricas. Por outro lado, denomina-se expressão
lógica à expressão cujos operadores são lógicos e cujos operandos são relações, variáveis e/ou
constantes do tipo lógico.
Tabela 11.1 – Operadores aritméticos Tabela 11.2 – Prioridade da operações

operador operação prioridade operação
-------------------------------- ---------------------------------------------
+ adição 1ª potenciação
– subtração 2ª multiplicação/divisão
* multiplicação 3ª adição/subtração
/ divisão
** potenciação
Tabela 11.4 – Operadores relacionais e lógicos
F77 F90 definição
Tabela 11.3 – Prioridade das operações -----------------------------------------------
prioridade operador .LT. < menor que
--------------------------------- .GT. > maior que
1ª aritmético .LE. <= menor ou igual a
2ª relacional .GE. >= maior ou igual a
3ª .NOT. .EQ. == igual a
4ª .AND. .NE. /= diferente de
5ª .OR. .AND. .AND. para conjunção
.OR. .OR. para disjunção
.NOT. .NOT. para negação
11.1 Exemplos:
1) Expressão matemática: Representação no Fortran:

1.1) P.( P − A) Ö (P*(P – A))**0.5 ou sqrt(P*(P – A))
 D 
1.2) A − B. C + −F+G Ö A – B*(C+D/(E+1) – F)+G
 E +1 
2) Variáveis Relação Resultado

---------------------------------------------------------------
X =1, Y=2, Z=5 X**2+Y.GT.Z .false.
X=4, Y=3, Z=1 X**2+Y>=Z .true.
12. Comandos IF e DO:
Num programa escrito em linguagem Fortran, aparecem em primeiro lugar as declarações,

seguidas por comandos que, se não houver indicação em contrário, deverão ser executadas
numa seqüência linear, seguindo-se o texto em que estão escritos, de cima para baixo. O fim
físico do programa é representado pela palavra chave END.
Dentro da estrutura seqüencial do Fortran, comentada no parágrafo acima, podem existir
estruturas condicionais ou de repetição. A estrutura condicional é representada pelo comando
IF, sendo executada quando uma determinada condição for verdadeira ou falsa, conforme as
suas diferentes formas apresentadas abaixo:
if (condição) comando_1 if (condição1) then

bloco_1
elseif (condição2) then
bloco_2
if (condição) then
elseif (condição3) then
bloco_1
bloco_3
endif
.
.
.
if (condição) then
bloco_1
else
else
bloco_n
bloco_2
endif
endif
Já a estrutura de repetição da linguagem Fortran é representada pela palavra-chave DO,

permitindo que uma seqüência de comandos seja executada repetidamente até que uma
determinada condição de interrupção seja satisfeita. As diferentes formas do comando DO
são apresentadas abaixo:
Versão F77:
do I = J,K do n I = J,K do I = J,K,L
bloco_de_comandos bloco_de_comandos bloco_de_comandos
enddo n continue enddo
Nas duas primeiras estruturas mostradas acima o bloco de comandos é executado

repetidamente com I=J, I=J+1, I=J+2, ... ,I=K, ao passo que na terceira estrutura o termo L
representa o incremento na variável I, de modo que o bloco de comandos é executado
repetidamente com I=J, I=J+L, I=J+2L, I=J+3L, ..., I=J+nL ≤ K.
Vale ressaltar que é possível abrir uma série de laços IF ou DO, um dentro do outro,
tomando-se o cuidado de sempre fechar os laços mais internos dentro dos laços mais externos.
Tal construção é conhecida pelo nome de ninho de IF ou de DO:
do I=1,5 if (condição_1) then

do J=3,10 if (condição_2) then
do K=2,9 bloco_de_comandos_1
bloco_de_comandos endif
enddo else
enddo if (condição_3) then
enddo bloco_de_comandos_2
endif
endif
Para o caso de se querer usar uma estrutura de repetição, porém sem saber inicialmente
quantas vezes o laço de DO deve ser executado, pode-se utilizar o comando DO WHILE:
do while (expressão_lógica)
bloco_de_comandos
enddo
Exemplos: ver exercises_5,6,7,...,11,12 na lista de programas em anexo.
13. Sub-rotinas e Funções:
Em relação à modularização de programas, a linguagem Fortran oferece facilidades

através de sub-rotinas (subroutine) e funções (function), o que torna possível a implementação
de programas modulares e estruturados, permitindo a construção de módulos subordinados a
um programa principal, que pode ser chamado várias vezes, sempre que for necessário:
! Programa Principal
....
! Chamada da Sub-rotina S1:
call S1(...)
! Chamada da Sub-rotina S2:
call S2(...)
! Chamada da Função F1:
A = F1(...)
...
contains
subroutine S1(...)
bloco_de_comandos
end subroutine S1
subroutine S2(...)
bloco_de_comandos
end subroutine S2
function F1(...)
bloco_de_comandos
end function F1
End program ! Término do programa principal
Vale ressaltar que é sempre conveniente dividir o programa principal em sub-rotinas de

modo que cada sub-rotina contém um algoritmo independente que pode inclusive ser
aproveitado para outros programas. Por exemplo, uma sub-rotina que resolve o sistema:
Ax=y pode ter muitas aplicações, não estando limitada a um programa específico. Pode-se
juntar uma série de sub-rotinas e funções para formar uma biblioteca de sub-rotinas, de forma
semelhante à biblioteca de funções intrínsecas que vem com o compilador.
Em F90, diferente das versões anteriores, todas as sub-rotinas e funções tem acesso à todas
as variáveis globais, ou seja, todos os dados são public. Pode-se fazer com que uma variável
se torne privativa (private) de uma sub-rotina ou função declarando ela novamente no corpo
da sub-rotina ou função, resolvendo o problema do comando COMMON que não é mais
necessário em F90. Portanto, é necessário que o usuário declare explicitamente no corpo da
sub-rotina ou função todas as variáveis que são privativas. Assim como na versão F77, no
F90 pode-se passar dados para sub-rotinas e funções usando argumentos.
Exemplos: ver exercises_13,14,15...,18 na lista de programas em anexo.
14. Arranjos ou Variáveis Compostas:
As variáveis compostas correspondem a posições de memória, identificadas por um único

nome, individualizadas por índices e cujo conteúdo é de um mesmo tipo. O nome de uma
variável composta é um identificador que obedece às mesmas regras de formação de
identificadores de variáveis simples. O nome se refere, coletivamente, a todos os elementos
da variável composta. Para referência a um elemento, é necessário colocar-se o nome da
variável, seguida, entre parênteses, de um ou mais índices. Em Fortran, esses índices podem
ser constantes inteiras ou variáveis inteiras. A maioria dos compiladores aceita também
expressões inteiras. Segue abaixo exemplos de variáveis compostas:
! Declaração de variáveis:
integer var_1 ! variável simples
integer vector_1(5), vector_2(10)
real vector_3(4), matriz_1(3,3)
real*8 matriz_2(2,3),matriz_3(3,3,3) ! pode possuir até 7 dimensões em F90
...
vector_1(3) = 2 ! terceiro elemento da variável vector_1
matriz_1(1,2) = 3.0 ! elemento na primeira linha e segunda coluna de matriz_1
...
var_1 = 2*vector_1(4)+vector_2(10)
...
! tentar referenciar: vector_1(6), vector_1(0) ou vector_1(-2) produz erros
! tentar referenciar: vector_1(2.5) também produz erros
No Fortran, as variáveis compostas unidimensionais (vetores) são utilizadas para

armazenar conjuntos de dados cujos elementos podem ser endereçados por um único índice.
O conjunto de dados referenciado por um nome e que necessite de mais de um índice para ter
seus elementos individualizados é dito composto multidimensional e a variável que o
armazena é denominada variável composta multidimensional (matrizes e tensores de ordem
superior). Nas variáveis compostas bi-dimensionais (matrizes ou tensores de segunda ordem),
convenciona-se que o primeiro índice indique a linha e o segundo a coluna.
Em geral, utilizam-se laços de DO para manipular os elementos de um arranjo.
14.1 Dimensionamento Dinâmico de Arranjos:
Em programas computacionais de médio e grande porte, de modo a evitar a perda de

memória do computador, é bastante útil utilizar o dimensionamento dinâmico de arranjos,
segundo o qual, pode-se:
• Manter um arranjo no tamanho zero, exceto quando estiver em uso.

• Aumentar e diminuir o tamanho de arranjos.
• Ler o tamanho de arranjos como dados em vez de fixar de antemão.
Porém, devem-se tomar certos cuidados: ao alterar o tamanho de um arranjo perde-se o seu
conteúdo e portanto deve-se armazenar o seu conteúdo em outro local caso se queira uma
cópia dos seus valores. Arranjos sem dimensões não podem ser passados para sub-rotinas
como argumentos, ou seja, é necessário fixar antes a sua dimensão. A seguir é apresentado o
funcionamento da alocação dinâmica de arranjos:
! declaração de variáveis:
! real*8, dimension(:), allocatable :: vector_1 ! vetor sem dimensão
! real*8, dimension(:,:), allocatable :: matriz_1 ! matriz sem dimensões
! integer n,m
...
read(*,*) n,m
allocate(vector_1(n)) ! definindo a dimensão do vetor
allocate(matriz_1(n,m)) ! definindo as dimensões da matriz
...
14.2 Operações com Arranjos em F90:
No Fortran F90 é possível fazer uma série de operações em parte ou na totalidade dos
elementos de um arranjo com expressões simples, sem a necessidade de se utilizar laços de
DO, conforme ocorria para o caso da versão F77:
! Declaração de Variáveis:
real*8 x(10),y(10),z(10),a(4),b(5),M(10,10),M1(3,3), prod
real*8 M2(3,2),M3(2,3), M4(3,3),M5(3,3)
...
z = x+y ! efetua a soma de cada um dos termos x(i)+y(i) isoladamente
z = x*3.0 ! efetua a multiplicação de cada um dos termos x(i) por 3.0
z =(x*y) ! efetua o produto de cada um dos termos x(i)*y(i) isoladamente
prod=sum(z) ! efetua o produto escalar dos vetores x*y
x=y ! arranjo x igual a y
a=x(1:4) ! inicializa o vetor a com os quatro primeiros termos de x
b(1:5)=x(1:5)+y(6:10) ! b(1)=x(1)+y(6), b(2)=x(2)+y(7), ...
M(1:10,1:10)=0.0 ! atribui o valor 0.0 a todos os termos da matriz M.
M1(1:3,1:3)=M(4:6,4:6) ! M1(1,1)=M(4,4), M1(1,2)=M(4,5),...
M3=transpose(M2) ! efetua a transposta da matriz
M5=M1+M4 ! soma de matrizes (mesma dimensão)
x(1:10) = M(1,1:10) ! vetor x igual a primeira linha da matriz M
MC=Matmul(MA,MB) ! multiplicação de matrizes: MA(n,m)*MB(m,k) = MC(n,k)
Exemplos: ver exercises_19,20,21...,23 na lista de programas em anexo.

Anexo - Lista de Programas
program exercise_5
! Objetivo: Definir a menção de um aluno com base na sua nota
real nota
! Entrada de Dados:
write(*,*) 'Digitar a nota do aluno: '
read (*,*) nota
if (nota<0.or.nota>10) then
write(*,*)'Nota deve ser positiva entre 0 e 10'
write(*,*)'Entre novamente com a nota:'
read (*,*) nota
endif
! Laços de IF:
if (nota==0) then
write(*,*)'Final Grade = SR'
elseif (nota>0.and.nota<3) then
write(*,*)'Final Grade = II'
elseif (nota>=3.and.nota<5) then
write(*,*)'Final Grade = MI'
write(*,*)'Final Grade = MM'
write(*,*)'Final Grade = MS'
else
write(*,*)'Final Grade = SS'
endif
end program
__________________________________________________________________________________________
program exercise_6
! Objetivo: Definir a menção de um aluno com base na sua nota e presença
real nota,attendance
! Entrada de Dados:
write(*,*) 'Digitar a nota do aluno: '
read (*,*) nota
if (nota<0.or.nota>10) then
write(*,*)'Nota deve ser positiva entre 0 e 10'
write(*,*)'Entre novamente com a nota:'
read (*,*) nota
endif
write(*,*) 'Digitar a presenca do aluno: '
read(*,*) attendance
! Laços de IF:
if (attendance<=75) then
else
if (nota==0) then
elseif (nota>0.and.nota<3) then
write(*,*)'Final Grade = II'
write(*,*)'Final Grade = MI'
write(*,*)'Final Grade = MM'

write(*,*)'Final Grade = MS'
else
write(*,*)'Final Grade = SS'
endif
endif
end program
__________________________________________________________________________________________
program exercise_7
! Objetivo: Rendimentos bancários
integer i,meses
real saldo,juros,taxa
! Entrada de Dados:
write(*,*) 'Digitar saldo original: '
read (*,*) saldo
write(*,*) 'Digitar taxa de juros (0-100%): '
read (*,*) taxa
write(*,*) 'Digitar numero de meses: '
read (*,*) meses
taxa=taxa/100.0
! Laços de DO:
do i=1,meses
juros=taxa*saldo
saldo=saldo+juros
write(*,*)'Mes:',i,' Juros:',juros,' Saldo:',saldo
enddo
end program
__________________________________________________________________________________________
program exercise_8
! Objetivo: Rendimentos bancários
! Mostrar laço de DO aberto
integer meses
real saldo,juros,taxa
! Entrada de Dados:
write(*,*) 'Digitar saldo original: '
read (*,*) saldo
write(*,*) 'Digitar taxa de juros (0-100%): '
read (*,*) taxa
saldo_inicial=saldo
taxa=taxa/100.0
! Laços de DO:
do
meses=meses+1
juros=taxa*saldo
saldo=saldo+juros
write(*,*)'Mes:',meses,' Juros:',juros,' Saldo:',saldo
if (saldo>2*saldo_inicial) stop
enddo
end program
__________________________________________________________________________________________
program exercise_9
! Objetivo: Achar a raiz quadrada de um número por iterações
real numero,raiz
integer i
! Entrada de dados:
write(*,*)'Entrar com o numero: '
read (*,*) numero
raiz = 1 ! Chute inicial (Não importa que seja muito longe)
do i=1,10
raiz = 0.5*(raiz+numero/raiz)
write(*,*)'Iteration: ',i,' Raiz: ',raiz
enddo
write(*,*)'Raiz por iteracoes : ',raiz
write(*,*)'Raiz pela funcao SQRT: ',sqrt(numero)
end program
__________________________________________________________________________________________
program exercise_10
! Objetivo: Cálculo dos momentos fletores ao longo de uma viga biapoiada

! M = M(x): momento ao longo da viga (calculado a cada metro)
real M,L,W,A,dx,distance
integer i
! Características Geométricas:
L = 10.0 ! comprimento total da viga
W = 100.0 ! carregamento concentrado
A = 8.0 ! distância do carregamento concentrado ao apoio esquerdo
dx = L/10
! Cálculo das reações de apoio

R1 = W*(L-A)/L ! reação no apoio esquerdo
R2 = W*A/L ! reação no apoio direito
! Cálculo dos momentos fletores

write(*,*)'Momentos fletores ao longo da viga: '
do i=0,10
distance =i*dx
if (distance<=A) then
M=R1*distance
else
M=R1*distance-W*(distance-A)
endif
write(*,*)'X = ',distance,' M= ',M
enddo
end program
__________________________________________________________________________________________
program exercise_11
! Objetivo: * Cálculo do fatorial de um número.

! * O fatorial será calculado utilizando-se variáveis: integer ou real*8.
! É importante ressaltar que as variáveis inteiras só podem armazenar valores
! no intervalo [-2147483648,2147483647].
integer ifact ! cálculo do fatorial como integer
real*8 rfact ! cálculo do fatorial como real*8
character*15 fileout
! Arquivo de saída de dados:

write(*,*)'Nome do arquivo de saida de dados - Max(15char): '
read (*,*) fileout
open(unit=10,file=fileout,status='unknown')
! Cálculo do Fatorial
ifact=1
rfact=1.0d0
write(*,*) ' i ifact rfact'
write(10,*)' i ifact rfact'
do i=1,20
ifact=ifact*i
rfact=rfact*i
write(*,*)i,ifact,rfact
write(10,*)i,ifact,rfact
enddo
end program
Arquivo de Saída de Dados (exercise_11.out):
i ifact rfact
1 1 1.000000000000000
2 2 2.000000000000000
3 6 6.000000000000000
4 24 24.000000000000000
5 120 120.000000000000000
6 720 720.000000000000000
7 5040 5040.000000000000000
8 40320 40320.000000000000000
9 362880 362880.000000000000000
10 3628800 3628800.000000000000000
11 39916800 3.991680000000000E+007
12 479001600 4.790016000000000E+008
13 1932053504 6.227020800000000E+009 ! Observação: 6.227e+09 = 6227000000 > 2147483647
14 1278945280 8.717829120000000E+010
15 2004310016 1.307674368000000E+012
16 2004189184 2.092278988800000E+013
17 -288522240 3.556874280960000E+014
18 -898433024 6.402373705728000E+015
19 109641728 1.216451004088320E+017
20 -2102132736 2.432902008176640E+018
__________________________________________________________________________________________
program exercise_12
! Objetivo: Cálculo das raízes de uma equação de segunda ordem:

! Ax2 + Bx + C = 0
! ----------------------------------------------------------------
! Nota sobre números complexos:
! Z=X+YI >>> Z=(X,Y)
! X: parte real
! Y: parte imaginária
! CONJG(Z)=X-YI
! ----------------------------------------------------------------
real*8 A,B,C,DELTA,X1,X2,TOL
complex*8 Z1, Z2
character*15 file_out
! Entrada de Dados:
TOL=1.0E-05 !TOL: tolerância para evitar divisão por zero
write(*,*)'Calculo das raizes de uma equacao de segunda ordem'
write(*,*)'Valor de coeficiente quadratico: '
read (*,*) A
if (ABS(A).LT.TOL) then
write(*,*)'O coeficiente quadratico deve ser maior que 1.0E-05'
stop
endif
write(*,*)'Valor do coeficiente linear: '
read (*,*) B
write(*,*)'Valor do coeficiente independente: '
read(*,*) C
write(*,*)'Nome do arquivo de saida de dados: '
read(*,*) file_out
! Calculo das raizes:

DELTA=B*B-4.*A*C
if (DELTA.GE.0.) then ! Caso 1: raízes reais
X1=(-1.0*B+SQRT(DELTA))/(2.0*A)
X2=(-1.0*B-SQRT(DELTA))/(2.0*A)
open(unit=10, file=file_out, status='unknown')
write(10,*) 'CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: '
write(10,*)
write(10,*) 'COEFICIENTE QUADRÁTICO :',A
write(10,*) 'COEFICIENTE LINEAR :',B
write(10,*) 'COEFICIENTE INDEPENDENTE:',C
write(10,50)'PRIMEIRA RAIZ - X1 :',X1
write(10,50)'SEGUNDA RAIZ - X2 :',X2
else ! Caso 2: raízes complexas
Z1=(CMPLX(-1.0*B)-CSQRT(CMPLX(DELTA)))/(CMPLX(2.0*A))
Z2=(CMPLX(-1.0*B)+CSQRT(CMPLX(DELTA)))/(CMPLX(2.0*A))
open(unit=10, file=file_out, status='unknown')
write(10,*) 'CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM: '
write(10,*)
write(10,*) 'COEFICIENTE QUADRÁTICO :',A
write(10,*) 'COEFICIENTE LINEAR :',B
write(10,*) 'COEFICIENTE INDEPENDENTE:',C
write(10,100)'PRIMEIRA RAIZ - Z1 :',Z1
write(10,100)'SEGUNDA RAIZ - Z2 :',Z2
endif
50 format(1X,A25,2X,F10.6)
100 format(1X,A25,2X,'(',F10.6,',',F10.6,')')
end program
Arquivos de Saída de Dados:
1. ( 2 raizes reais diferentes)

CÁLCULO DAS RAIZES DE UMA EQUAÇÃO DE 2a ORDEM:
COEFICIENTE QUADRÁTICO : 2.000000

COEFICIENTE LINEAR : 3.000000
COEFICIENTE INDEPENDENTE: 1.000000
PRIMEIRA RAIZ - X1 : -.500000
SEGUNDA RAIZ - X2 : -1.000000
2. ( 2 raizes reais iguais )


COEFICIENTE LINEAR : -4.000000
PRIMEIRA RAIZ - X1 : 2.000000
SEGUNDA RAIZ - X2 : 2.000000
3. ( 2 raizes complexas )

COEFICIENTE LINEAR : 2.000000
PRIMEIRA RAIZ - Z1 : ( -.500000, -.866025)
SEGUNDA RAIZ - Z2 : ( -.500000, .866025)
__________________________________________________________________________________________
program exercise_13
! Objetivo: Escrever um programa que leia os comprimentos dos três lados a,b e c de um
! paralelepípedo, calcule e escreva o valor da sua diagonal e do seu volume:
! Volume = a*b*c e Diagonal = sqrt(sqrt(a^2+b^2)+c^2)
! Observação: Utilização de funções (function)
real a,b,c,d,vol
! Entrada de Dados;
write(*,*)'Entrar com os comprimentos dos lados (a,b,c):'
read (*,*) a,b,c
! Cálculo do volume e diagonal do paralelepípedo:
vol = volume(a,b,c)
d = hipotenusa(hipotenusa(a,b),c)
write(*,*) 'Volume = ',vol
write(*,*) 'Diagonal = ',d
contains
function volume(x,y,z)
real x,y,z,volume
volume =x*y*z
end function volume
function hipotenusa(x,y)
real x,y,hipotenusa
hipotenusa =sqrt(x**2+y**2)
end function hipotenusa
end program
__________________________________________________________________________________________
program exercise_14
! Objetivo: Escrever um programa que calcule a distância entre dois pontos no espaço,
! sendo fornecidas as coordenadas X1,Y1,Z1 e X2,Y2,Z2.
! Observação: Utilização de funções (function)
real x1,y1,z1,x2,y2,z2,dist
! Entrada de Dados;
write(*,*)'Entrar com as coordenadas X1,Y1 e Z1 do primeiro ponto:'
read (*,*) x1,y1,z1
write(*,*)'Entrar com as coordenadas X2,Y2 e Z2 do segundo ponto:'
read (*,*) x2,y2,z2
! Cálculo da distância entre os pontos no espaço:

dist = distance(x1,y1,z1,x2,y2,z2)
write(*,*) 'Distancia entre os pontos = ',dist
contains
function distance(x1,y1,z1,x2,y2,z2)
real x1,y1,z1,x2,y2,z2,distance
distance =sqrt((x2-x1)**2+(y2-y1)**2+(z2-z1)**2)
end function distance
end program
__________________________________________________________________________________________
program exercise_15
! Objetivo: Cálculo do fatorial utilizando-se sub-rotinas (subroutine)

! fatorial(n) = n! = 1*2*3*...*n
real*8 fac_n
integer n
! Cálculo do fatorial de 1,2,...,10:

write(*,*)' n fatorial(n)'
do n=1,10
call factorial(n,fac_n)
write(*,10)n,fac_n
10 format(i3,3x,f10.2)
enddo
contains
subroutine factorial(n,fac_n)
real*8 fac_n
integer n
fac_n=1
do i=2,n
fac_n=i*fac_n
enddo
end subroutine factorial
end program
__________________________________________________________________________________________
program exercise_16
! Objetivo: Escrever um programa que calcule a função:
! exp(x)=1+x+(x^2/2!)+(x^3/3!)+...
! Observação: Na função acima deve-se incluir apenas os termos maiores que tol=1.0E0-6.
! Imprima os resultados e compare com a função interna exp
integer i
real*8 x,fexp,tol,parcela
character*15 file_out
! Entrada de dados:
write(*,*)'Calculo da funcao F=exp(x)'
write(*,*)
write(*,*)'Valor de x: '
read (*,*) x
write(*,*)'Nome do arquivo de saida de dados (Max=15char): '
read (*,*) file_out
! Cálculo da função exponencial de x:

tol = 1.0e-06 ! tolerâncial
fexp = 0.0d0 ! inicializar a função
parcela = 1.0d0 ! primeira parcela
i=0
do while (parcela>tol)
fexp=fexp+parcela
i=i+1
parcela=(x**i)/fact(i)
enddo
! Imprimir dados de saída:

open (unit=10, file=file_out, status='unknown')
write(10,*)'Valor da funcao exponencial de X: '
write(10,*)'----------------------------------------'
write(10,*)
write(10,*)'Valor de x = ', x
write(10,*)'F(x)=1+x+(x^2/2!)+(x^3/3!)+... = ',fexp
write(10,*)'F(x)=exp(x) = ',exp(x)
contains
function fact(n)
integer n,j
real*8 fact,temp
temp=1
do j=2,n
temp=temp*j
enddo
fact=temp
end function fact
end program
Arquivo de saída de dados (exercise_16.out):

Valor da funcao exponencial de X:
----------------------------------------
Valor de x = 5.000000000000000
F(x)=1+x+(x^2/2!)+(x^3/3!)+... = 148.413158521647700
F(x)=exp(x) = 148.413159102576600
__________________________________________________________________________________________
program exercise_17
! Objetivo: Dados dois números distintos,colocá-los em ordem crescente
real*8 A,B
! Entrada de dados:
write(*,*) 'Entrar com os valores de A e B:'
read (*,*) A,B
write(*,10)A,B
10 format(/' Ordem original dos numeros: ',/,f10.2,/,f10.2)
! Colocar números em ordem crescente:

if (A>B) then
call trocar(A,B)
endif
write(*,20)A,B
20 format(' Numeros em ordem crescente: ',/,f10.2,/,f10.2)
contains
subroutine trocar(A,B)
real*8 A,B,aux
aux = A
A=B
B = aux
end subroutine trocar
end program
__________________________________________________________________________________________
program exercise_18
! Objetivo: Encontrar uma das raizes de uma função f(x)=0 usando o método de Newton
! Método de Newton: x = x-f(x)/df(x)
! Declaração de variáveis;
implicit none
integer :: its = 0 ! contador de iterações
integer :: maxits = 20 ! número máximo de iterações
logical :: converged = .false. ! indicador de convergência
real*8 :: toler = 1.0e-06 ! tolerância
real*8 :: x = 2.0d0 ! chute inicial
! Determinação da raiz da equação:

write(*,*)' x f(x) '
write(*,*)'-----------------------------------------------------'
do while (.not.converged.and.its<maxits) ! true and true = true : executa
x=x-f(x)/df(x) ! false and true = false: nao executa
write(*,*)x,f(x)
its=its+1
converged=abs(f(x))<=toler
enddo
if (converged) then
write(*,*)' Metodo de Newton convergiu'
else
write(*,*)' Metodo de Newton Nao convergiu'
endif
write(*,*)' Raiz da funcao = ',x
contains
function f(x) ! Função qualquer escolhida pelo usuário f(x) = x^3+x-d

real*8 f,x
f=x**3+x-3
end function
function df(x) ! Derivada da função: df(x) = 3*x^2+1

real*8 df,x
df = 3*x**2+1
end function df
end program
__________________________________________________________________________________________
program exercise_19
! Objetivo: Calcular a média e o desvio padrão de uma série de números
integer i,n
real std,media,x(100)
character*15 file_in
! Entrada de Dados:
write(*,*)'Nome do arquivo de entrada de dados (Max=15Char): '
read (*,*) file_in
open (unit=10, file=file_in, status='unknown')
media=0.0
std =0.0
read (10,*)n
do i=1,n
read(10,*)x(i)
media=media+x(i)
enddo
! Cálculo da Média e Desvio Padrão:

media = media/n
do i=1,n
std=std+(x(i)-media)**2
enddo
std=sqrt(std/(n-1))
write(*,*)'Valor Medio = ',media
write(*,*)'Desvio Padrao = ',std
end program
__________________________________________________________________________________________
program exercise_20
! Objetivo: Calcular a média e o desvio padrão de uma série de números.
! Usar subrotinas e passar arranjo usando argumentos.
integer i,n
real std,media,x(100)
! Entrada de Dados:
read (*,*) file_in
read (10,*)n
do i=1,n
read(10,*)x(i)
enddo
! Chamar subrotina e imprimir resultados:

call stats(x,n,media,std)
contains
! Subrotina Stats:
subroutine stats(x,n,media,std) ! passagem de argumentos
real std,media,x(100) ! variáveis privativas da subrotina (private)
integer i,n
media=0.0
std =0.0
do i=1,n
media=media+x(i)
enddo
media = media/n
do i=1,n
enddo
std=sqrt(std/(n-1))
end subroutine stats
end program
__________________________________________________________________________________________
program exercise_21
! Objetivo: Calcular a média e o desvio padrão de uma série de números.

! Usar subrotinas e passar arranjo usando argumentos.
! Usar alocação dinâmica para definir o vetor contendo os números.
integer i,n
real std,media
real,dimension(:), allocatable::x ! Importante: declaração de variável sem dimensão definida
! Entrada de Dados:
read (*,*) file_in
read (10,*)n
allocate (x(n)) ! definir dimensão do vetor
do i=1,n
read(10,*)x(i)
enddo
! Chamar subrotina e imprimir resultados:

! Obs: sempre definir a dimensão do vetor ou matriz antes de passar para subrotina.
call stats(x,n,media,std)
contains
! Subrotina Stats:
subroutine stats(x,n,media,std) ! passagem de argumentos
real std,media ! variáveis privativas da subrotina (private)
integer i,n
real, dimension(:) :: x ! vetor alocado dinamicamente no programa principal
media=0.0
std =0.0
do i=1,n
media=media+x(i)
enddo
media = media/n
do i=1,n
enddo
std=sqrt(std/(n-1))
end subroutine stats
end program
__________________________________________________________________________________________
program exercise_22
! Objetivo: Testar alocação dinâmica de matrizes:
integer tamanho,n
real, dimension(:), allocatable::x
! Testando alocação dinâmica:

tamanho = size(x)
write(*,*)' Tamanho (antes de definir dimensao) = ',tamanho
open (unit=10, file='exercise_22.dat', status='unknown')
read (10,*)n
allocate(x(n))
do i=1,n
read(10,*)x(i)
enddo
tamanho=size(x)
write(*,*)' Tamanho (depois de definir dimensao) = ',tamanho
write(*,*)' Vetor x: '
do i=1,n
write(*,*)x(i)
enddo
end program
__________________________________________________________________________________________
program exercise_23
! Objetivo: Multiplicação de Matrizes: A(n,m)*B(m,k)=C(n,k),utilizando diferentes técnicas
integer i,j,n,m,k
integer in,io
real, dimension(:,:), allocatable::A,B,C
character*15 file_in,file_out
! Canais de Entrada e Saída de Dados:

in = 10
io = 20
! Entrada de Dados:
write(*,*)'Nome do arquivo de entrada de dados (Max=15char): '
read (*,*) file_in
open (in, file=file_in, status='unknown')
write(*,*)'Nome do arquivo de saída de dados (Max=15char): '
read (*,*) file_out
open (io, file=file_out, status='unknown')
read (in,*) n,m,k
allocate (A(n,m),B(m,k),C(n,k))
do i=1,n
read(in,*)(A(i,j),j=1,m)
enddo
do i=1,m
read(in,*)(B(i,j),j=1,k)
enddo
write(io,*)'Matriz A: '
do i=1,n
write(io,*)(A(i,j),j=1,m)
enddo
write(io,*)'Matriz B: '
do i=1,m
write(io,*)(B(i,j),j=1,k)
enddo
! Testar possibilidade de multiplicação:

t1=size(A,2) ! número de colunas da matriz A
t2=size(B,1) ! número de linhas da matriz B
if (t1/=t2) then
write(*,*)' Impossibilidade de calcular C=A*B - Ajustar Dimensoes'
stop
endif
! Multiplicação de matrizes - versão F77:

call prodF77(A,B,C)
write(io,*)'Matriz C=A*B utilizando prodF77: '
do i=1,n
write(io,*)(C(i,j),j=1,k)
enddo
! Multiplicação de matrizes - versão F90:

call prodF90(A,B,C)
write(io,*)'Matriz C=A*B utilizando prodF90: '
do i=1,n
enddo
! Multiplicação de matrizes - comando Matmul:

call prod_function(A,B,C)
write(io,*)'Matriz C=A*B utilizando prod_function: '
do i=1,n
enddo
contains
subroutine prodF77(A,B,C)
real, dimension(:,:) :: A,B,C
integer i,j,l
do i=1,n
do j=1,k
C(i,j)=0.0
do l=1,m
C(i,j)=C(i,j)+A(i,l)*B(l,j)
enddo
enddo
enddo
end subroutine prodF77
subroutine prodF90(A,B,C)
integer i,j
C(1:n,1:k)= 0.0
do i=1,n
do j=1,k
C(i,j)=sum(A(i,1:m)*B(1:m,j))
enddo
enddo
end subroutine prodF90
subroutine prod_function(A,B,C)
C=Matmul(A,B)
end subroutine prod_function
end program
Arquivo de Entrada de Dados (exercise_23.out)

3 3 3 ! n,m,k
1.0 2.0 3.0
2.0 3.0 4.0
3.0 4.0 5.0
1.0 1.0 1.0
2.0 2.0 2.0
3.0 3.0 3.0
Arquivo de Saída de Dados (exercise_23.out)

Matriz A:
1.000000 2.000000 3.000000
2.000000 3.000000 4.000000
3.000000 4.000000 5.000000
Matriz B:
1.000000 1.000000 1.000000
2.000000 2.000000 2.000000
3.000000 3.000000 3.000000
Matriz C=A*B utilizando prodF77:
14.000000 14.000000 14.000000
20.000000 20.000000 20.000000
26.000000 26.000000 26.000000
14.000000 14.000000 14.000000
20.000000 20.000000 20.000000
26.000000 26.000000 26.000000
Matriz C=A*B utilizando prod_function:
14.000000 14.000000 14.000000
20.000000 20.000000 20.000000
26.000000 26.000000 26.000000
Arquivo de Entrada de Dados (teste_23.out)

(Matrizes não quadradas)
3 2 3 ! n,m,k
1.0 2.0
2.0 3.0
3.0 4.0
1.0 1.0 1.0
2.0 2.0 2.0
Arquivo de Saída de Dados (teste_23.out)

(Matrizes não quadradas)
Matriz A:
1.000000 2.000000
2.000000 3.000000
3.000000 4.000000
Matriz B:
1.000000 1.000000 1.000000
2.000000 2.000000 2.000000
5.000000 5.000000 5.000000
8.000000 8.000000 8.000000
11.000000 11.000000 11.000000
5.000000 5.000000 5.000000
8.000000 8.000000 8.000000
11.000000 11.000000 11.000000
Matriz C=A*B utilizando prod_function:
5.000000 5.000000 5.000000
8.000000 8.000000 8.000000
11.000000 11.000000 11.000000
__________________________________________________________________________________________
! *******************************************************
! Programa: Matrix
! Operações com vetores e matrizes no F90
! Author: Renato César Gavazza Menin
! *******************************************************
program matrix
implicit double precision(a-h,o-z)

implicit integer (i-n)
real*8 A(3),B(3),Soma(3),Subt(3)
real*8 MA(3,3),MB(3,3),MS(3,3),MT(3,3),MABST(6,6)
real*8 aM(3,3),MM(3,3),MABT(3,3),matAB(3,3)
real*8 Config_C0(3,10),E_0(3,3)
real*8 V1(3),V2(3)
real*8 MC(3,4),V3(4)
real*8 PV(3),norma,m1,m2,m3,m4,m5,m6
integer io
character*15 fileout
io = 20
write(*,*)'Program: Matrix '
write(*,*)'--------------------------------'
write(*,*)
write(*,*)'Output File Name ? (Max 15 Char)'
read (*,*) fileout
open (io,file=fileout,status='unknown')
write(*,*)
! 1. Soma e subtração de vetores:

! ---------------------------------------
! Vetor A:
A(1)=1
A(2)=2
A(3)=3
! Vetor B:
B(1)=10
B(2)=20
b(3)=30
Soma = A + B
Subt = A - B
write(io,*)'Vetor Soma: '
do i=1,3
write(io,*)Soma(i)
enddo
write(io,*)'Vetor Subt: '
do i=1,3
write(io,*)Subt(i)
enddo
! 2. Transposição e soma de matrizes:

! -------------------------------------------
! Matriz MA:
MA(1,1)=1.0
MA(1,2)=2.0
MA(1,3)=3.0
MA(2,1)=4.0
MA(2,2)=5.0
MA(2,3)=6.0
MA(3,1)=7.0
MA(3,2)=8.0
MA(3,3)=9.0
! Matriz MB:
MB(1,1)=1.0
MB(1,2)=0.0
MB(1,3)=0.0
MB(2,1)=0.0
MB(2,2)=1.0
MB(2,3)=0.0
MB(3,1)=0.0
MB(3,2)=0.0
MB(3,3)=1.0
! Matriz Transposta:
MT=Transpose(MA)
write(io,*)'Matriz Transposta: '
do i=1,3
write(io,*)(MT(i,j),j=1,3)
enddo
! Soma de Matrizes Quadradas:

MS=MA+MB
write(io,*)'Soma de Matrizes: '
do i=1,3
write(io,*)(MS(i,j),j=1,3)
enddo
! 3. Composição de matrizes:
! ---------------------------------
MABST(1:3,1:3)=MA
MABST(1:3,4:6)=MB
MABST(4:6,1:3)=MS
MABST(4:6,4:6)=MT
write(io,*)'Matriz MABST: '
do i=1,6
write(io,10)(MABST(i,j),j=1,6)
10 format(f4.1,X,f4.1,X,f4.1,X,f4.1,X,f4.1,X,f4.1)
enddo
! Configuração Inicial:
do i=1,3
do j=1,10
Config_C0(i,j)=i+j
enddo
enddo
E_0(1:3,1)=Config_C0(1,1:3)
E_0(1:3,2)=Config_C0(1,4:6)
E_0(1:3,3)=Config_C0(1,7:9)
write(io,*)'Matriz Config_C0: '
do i=1,3
write(io,15)(E_0(i,j),j=1,3)
15 format(f4.1,X,f4.1,X,f4.1)
enddo
! 4. Multiplicação de matrizes:
! ------------------------------------
! 4.1 Multiplicação de Matriz Quadrada por Escalar:
aM=2.0*MA
write(io,*)'Multiplicar matriz por escalar: '
do i=1,3
write(io,*)(aM(i,j),j=1,3)
enddo
! 4.2 Multiplicação de matrizes - Função Interna "MATMUL"
MM=MATMUL(MA,MB)
write(io,*)'Multiplicar matrizes - MA*MB: '
do i=1,3
write(io,*)(MM(i,j),j=1,3)
enddo
MABT=MATMUL(MM,MT)
write(io,*)'Multiplicar matrizes - MA*MB*MT: '
do i=1,3
write(io,*)(MABT(i,j),j=1,3)
enddo
MM=MATMUL(MM,MT)
write(io,*)'Multiplicar matrizes - MM=MA*MB*MT: '
do i=1,3
write(io,*)(MM(i,j),j=1,3)
enddo
! 4.3 Multiplicação de Matriz e Vetor:

! Obs: [V1]3x1 = [MA]3x3 * [A]3x1
V1=MATMUL(MA,A)
write(io,*)'Multiplicar matriz e vetor: '
do i=1,3
write(io,*)V1(i)
enddo
! 4.4 Multiplicação de Vetor e Matriz:

! Obs: [V2]1x3 = [A]1x3 * [MA]3x3
V2=MATMUL(A,MA)
write(io,*)'Multiplicar vetor e matriz: '
do i=1,3
write(io,*)V2(i)
enddo
! 4.5 Multiplicação de Vetor e Matriz Não Quadrada:

! Obs: [V3]1x4 = [A]1x3 * [MC]3x4
MC(1:3,1:3)=MA
MC(1:3,4)=A
V3=MATMUL(A,MC)
write(io,*)'Multiplication of vector by non quadratic matrix: '
do i=1,4
write(io,*)V3(i)
enddo
! 5. Subrotina para o cálculo do produto vetorial:

! --------------------------------------------------------
call cross(A,V1,PV)
write(io,*)'Produto Vetorial - Subrotina Cross: '
do i=1,3
write(io,*)PV(i)
enddo
! 6. Função para o cálculo da norma do vetor:

! -------------------------------------------
norma=norm(A)
write(io,*)'Norma de Vetor - Function Norm: '
write(io,*)'Norm = ',norma
! 7. Encontrar o valor máximo de uma sequência:

! --------------------------------------------
write(io,*)'Encontrar valor maximo de sequencia: '
m1=max(1,2,3)
m2=max(-1,-2,-3)
m3=max(-3,0,1)
m4=max(1.1,3.5,5.5)
m5=max(-3.5,0.0,2.0)
m6=max(MA(1,1),MA(1,2),MA(1,3))
write(io,*)'m1=max(1,2,3) = ',m1
write(io,*)'m2=max(-1,-2,-3) = ',m2
write(io,*)'m3=max(-3,0,1) = ',m3
write(io,*)'m4=max(1.1,3.5,5.5) = ',m4
write(io,*)'m5=max(-3.5,0,2) = ',m5
write(io,*)'m6=max(MA(1,1),MA(1,2),MA(1,3))= ',m6
! 8. Simetrização de uma matriz:

! --------------------------------------
MA=MA+transpose(MA)
MA=0.5*MA
write(io,*)'[MA] = ([MA]+[MA]t)/2: '
do i=1,3
write(io,*)(MA(i,j),j=1,3)
enddo
! 9. Multiplicação de matriz e transposta:

! -----------------------------------------------
! Reestabelecer Matriz MA:
MA(1,1)=1.0
MA(1,2)=2.0
MA(1,3)=3.0
MA(2,1)=4.0
MA(2,2)=5.0
MA(2,3)=6.0
MA(3,1)=7.0
MA(3,2)=8.0
MA(3,3)=9.0
MA=Matmul(MA,transpose(MA))
write(io,*)'[MA] = [MA]*transpose[MA]: '
do i=1,3
write(io,*)(MA(i,j),j=1,3)
enddo
! 10. Multiplicação de vetor(3,1) e vetor(1,3):

! -----------------------------------------------------
matAB=vecmul(A,B)
write(io,*)'[matAB] = vecmul(A,B): '
do i=1,3
write(io,*)(matAB(i,j),j=1,3)
enddo
CONTAINS
Subroutine cross(A,B,PV)
real*8 A(3),B(3),PV(3)
PV(1)=A(2)*B(3)-A(3)*B(2)
PV(2)=A(3)*B(1)-A(1)*B(3)
PV(3)=A(1)*B(2)-A(2)*B(1)
end subroutine cross
Function norm(V)
real*8 V(3),norm
norm=dsqrt(V(1)*V(1)+V(2)*V(2)+V(3)*V(3))
end function norm
Function vecmul(A,B)
real*8 A(3),B(3),mat(3,3),vecmul(3,3)
integer i,j
do i=1,3
do j=1,3
mat(i,j)=A(i)*B(j)
enddo
enddo
vecmul=mat
end function vecmul
End ! Término do Programa Principal
Arquivo de Saída de Dados (matrix.out):
Vetor Soma:
11.000000000000000
22.000000000000000
33.000000000000000
Vetor Subt:
-9.000000000000000
-18.000000000000000
-27.000000000000000
Matriz Transposta:
1.000000000000000 4.000000000000000 7.000000000000000
2.000000000000000 5.000000000000000 8.000000000000000
3.000000000000000 6.000000000000000 9.000000000000000
Soma de Matrizes:
2.000000000000000 2.000000000000000 3.000000000000000
4.000000000000000 6.000000000000000 6.000000000000000
7.000000000000000 8.000000000000000 10.000000000000000
Matriz MABST:
1.0 2.0 3.0 1.0 .0 .0
4.0 5.0 6.0 .0 1.0 .0
7.0 8.0 9.0 .0 .0 1.0
2.0 2.0 3.0 1.0 4.0 7.0
4.0 6.0 6.0 2.0 5.0 8.0
7.0 8.0 10.0 3.0 6.0 9.0
Matriz Config_C0:
2.0 5.0 8.0
3.0 6.0 9.0
4.0 7.0 10.0
Multiplicar matriz por escalar:
2.000000000000000 4.000000000000000 6.000000000000000
8.000000000000000 10.000000000000000 12.000000000000000
14.000000000000000 16.000000000000000 18.000000000000000
Multiplicar matrizes - MA*MB:
1.000000000000000 2.000000000000000 3.000000000000000
4.000000000000000 5.000000000000000 6.000000000000000
7.000000000000000 8.000000000000000 9.000000000000000
Multiplicar matrizes - MA*MB*MT:
14.000000000000000 32.000000000000000 50.000000000000000
32.000000000000000 77.000000000000000 122.000000000000000
50.000000000000000 122.000000000000000 194.000000000000000
Multiplicar matrizes - MM=MA*MB*MT:
14.000000000000000 32.000000000000000 50.000000000000000
32.000000000000000 77.000000000000000 122.000000000000000
50.000000000000000 122.000000000000000 194.000000000000000
Multiplicar matriz e vetor:
14.000000000000000
32.000000000000000
50.000000000000000
Multiplicar vetor e matriz:

30.000000000000000
36.000000000000000
42.000000000000000
Multiplication of vector by non quadratic matrix:
30.000000000000000
36.000000000000000
42.000000000000000
14.000000000000000
Produto Vetorial - Subrotina Cross:
4.000000000000000
-8.000000000000000
4.000000000000000
Norma de Vetor - Function Norm:
Norm = 3.741657386773941
Encontrar valor maximo de sequencia:
m1=max(1,2,3) = 3.000000000000000
m2=max(-1,-2,-3) = -1.000000000000000
m3=max(-3,0,1) = 1.000000000000000
m4=max(1.1,3.5,5.5)= 5.500000000000000
m5=max(-3.5,0,2) = 2.000000000000000
m6=max(MA(1,1),MA(1,2),MA(1,3))= 3.000000000000000
[MA] = ([MA]+[MA]t)/2:
1.000000000000000 3.000000000000000 5.000000000000000
3.000000000000000 5.000000000000000 7.000000000000000
5.000000000000000 7.000000000000000 9.000000000000000
[MA] = [MA]*transpose[MA]:
14.000000000000000 32.000000000000000 50.000000000000000
32.000000000000000 77.000000000000000 122.000000000000000
50.000000000000000 122.000000000000000 194.000000000000000
[matAB] = vecmul(A,B):
10.000000000000000 20.000000000000000 30.000000000000000
20.000000000000000 40.000000000000000 60.000000000000000
30.000000000000000 60.000000000000000 90.000000000000000
__________________________________________________________________________________________
REFERÊNCIAS BIBLIOGRÁFICAS:
• H.M. Deitel & P.J.Deitel, “Como programar em C”, Livros Técnicos e Científicos Editora, S.A., Rio de
Janeiro , 1994.
• S.J. Chapman, “Fortran 90/95 for Scientists and Engineers”, WCB/McGraw-Hill, USA, 1998.
• J. Liberty, “SAMS Teach Yourself C++ in 21 Days”, Fourth Edition, SAMS Publishing, Indiana / USA,
2001.
• A.Huerta, J. Sarrate, A.R. Ferran, “Métodos numéricos, Introducion, aplicaciones y programacion”,
Universiat Politécnica de Catalunya, Barcelona, 1998.
• H. Farrer, C.G. Becker, E.C. Faria, “Fortran Estruturado”, Editora Guanabara Koogan, Rio de Janeiro,
1992.
• P. W. Partridge, “Notas de aula do curso: Métodos Computacionais / 1º Semestre de 2002”, Brasília,
2002.

Fortran 90

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Fortran 90

Загружено:

Авторское право:

Доступные форматы

Disciplina: Métodos Computacionais / 1º Semestre de 2005

Parte 1 – Conceitos Fundamentais da Linguagem Fortran – Versão F90

Autor: Renato César Gavazza Menin

Forma Vantagens Desvantagens

Os programadores escrevem instruções em várias linguagens de programação, algumas

adiciona o Termo_B ao Termo_A e armazena o resultado no Termo_C, porém isto é feito de

O uso do computador aumentou rapidamente com o advento das linguagens assembly,

Termo_C = Termo_A + Termo_B : linguagem de alto nível

3. Uso da Linguagem Fortran em Computadores:

A utilização da linguagem Fortran para resolver um problema em um computador faz-se,

• Definição do Problema. É a descrição e a delimitação do problema a ser resolvido,

• Análise de Resultados. Os resultados obtidos pelas primeiras execuções de um

4. Formatação de um programa em Fortran:

O texto de um programa em Fortran 77 deve ficar disposto em linhas. As linhas devem

• colunas 1 a 5 para conter o número do comando ou da declaração (label ou rótulo),

Um comando ou declaração pode continuar nas colunas 7 a 72 de várias linhas

Output = input1 + input2

Output = input1 &

5. Estrutura de um Programa em Fortran:

Cada programa em Fortran consiste de um agrupamento de declarações executáveis e não

Estrutura de um Programa Simples: Program exercise_1

! Read the numbers:

! Multiply the numbers:

! Write out the result:

• F77: identificador pode ter no máximo 6 caracteres.

9 26 letras do alfabeto (a,b,c,d,...,w,x,y,z)

1. Integer: 9 armazena em forma exata até o limite, sem parte decimal.

2. Real: 9 números reais, ou seja, com parte decimal em precisão simples.

3. Real*8: 9 números reais, ou seja, com parte decimal em precisão dupla.

4. Logical: 9 é um valor lógico, que só pode ser verdadeiro ou falso, usado em

5. Character: 9 constante literal que representa qualquer seqüência de caracteres.

6.1 Declaração de Constantes e Variáveis:

integer var1, var2 ! declaração de variáveis do tipo inteiro.

6.2 Inicialização de Valores de Variáveis:

6.3 Programa com Diferentes Tipos de Variáveis:

! Declaração de variáveis do programa:

! Inicialização explícita de variáveis:

! Operações com variáveis:

! Imprimir os resultados na tela do computador:

Impressão de Resultados na Tela do Computador:

7. Leitura e Impressão de Dados em Arquivo Externo:

No caso de uma grande quantidade de dados é sempre interessante a leitura e a impressão

Open (Unit = n, File = ‘nome-ext-arquivo’, Status = ‘estado’)

• n: variável ou constante, inteira e não negativa que identifica a unidade de entrada ou

! Declaração de variáveis do programa:

! Abertura de arquivos externos para entrada e saída de dados:

! Leitura de Dados do Arquivo de Entrada de Dados:

! Operações com variáveis:

! Imprimir os resultados na tela do computador:

O comentário é um texto ou simplesmente uma frase utilizada para melhorar a clareza do

9. Formatação de Dados de Entrada ou Saída:

Na linguagem Fortran, é através da especificação format, que é descrito como os dados

• u: é uma constante positiva ou variável contendo um valor inteiro positivo, que

Especificação Tipo de Variável Observação

! Declaração de variáveis do programa:

! Abertura de arquivos externos para entrada e saída de dados:

! Leitura de Dados do Arquivo de Entrada de Dados:

! Operações com variáveis:

! Imprimir os resultados no arquivo de saída sem formatação:

! Imprimir os resultados no arquivo de saída com formatação:

Arquivo de Entrada de Dados / Exercise_4.dat Arquivo de Saída de Dados / Exercise_4.out

Imprimir Resultados - format:

10. Funções Internas: