CPC782
Fundamentos de Programação
Introdução ao Fortran
aula 2/3
Renato N. Elias / Marcos A. D. Martins
material disponível em: http://www.nacad.ufrj.br/~rnelias/fortranhttp://www.nacad.ufrj.br/~rnelias/fortran
Revisão da Aula 1/3 – parte 1
Programas– instruções utilizadas pelo computador para realizar uma tarefa
Construindo programas (programando):– Redação do programa em linguagem de ser humano utilizando uma
sintaxe própria (linguagem de programação)– Tradução da linguagem de ser humano para a linguagem de máquina
(compilação)– Empacotamento dos arquivos, em linguagem de máquina, que irão
compor as instruções que o computador irá executar (“linkedição”) Fortran: uma dentre várias linguagens de programação
existentes– Fácil de aprender– Excelente para realização de cálculos– Péssima para computação gráfica, internet, bancos de dados– Milhares de bibliotecas científicas desenvolvidas em Fortran e
disponíveis para uso
Revisão da Aula 1/3 – parte 2
Fortran – elementos da linguagem:– Definições básicas que definem a linguagem: formatos de arquivo,
estrutura de um programa, símbolos, caracteres de comentários e continuação de linha, operações aritméticas e lógicas, tipos, declaração de variáveis, comandos condicionais, comandos de repetição
– Formato fixo (F77) e livre (F90 e mais novos)
– Não é sensível a MAIÚSCULAS e minúsculas
– Variável: nome que identifica uma posição de memória onde contém um valor armazenado
– Tipo: identifica o quanto uma variável ocupa na memória
– Tipos básicos em Fortran:integer, real*4, real*8, character, logical, complex
– Comandos condicionais:(if, then, else, elseif, endif), (select case, end select)
– Comandos de repetição:do, do while, do infinito
Aula 2
Comandos de Entrada e Saída (E/S)– PRINT, WRITE, READ, FORMAT, OPEN, CLOSE
Variáveis indexadas– Declaração e dimensionamento de arrays (DIMENSION)
– Terminologia (Posto, Extensão, Forma e Tamanho)
– Iniciando e acessando arrays
– Seleção de trechos de arrays e armazenamento na memória
– Operações simples com arrays
– Arrays em funções intrínsecas
– Comandos condicionais para arrays (WHERE e FORALL)
– Funções específicas para operações com arrays
Alocação dinâmica de memória– ALLOCATABLE, ALLOCATE, DEALLOCATE e ALLOCATED
Ponteiros em Fortran90
Comandos de Entrada e Saída (E/S)
São comandos utilizados para informar os dados que o programa irá processar (dados de entrada) e como o programa irá mostrar os resultados para nós (dados de saída).
Comandos básicos de entrada e saída:– print: saída de dados (somente na tela)– write: saída de dados (tela, arquivo, etc...)– read: entrada de dados (tela, arquivo, etc...)
Alguns comandos auxiliares de entrada e saída– format: formatação de entrada e saída em ASCII– open, close, inquiry, eof: comandos associados a
manipulação de arquivos
Unidades de entrada e saída (E/S)
As unidades de entrada e saída são as fontes de dados utilizados pelo Fortran;
As unidades mais comumente usadas em Fortran são: tela (saída), teclado (entrada) e arquivo (entrada e saída);
Internamente o Fortran identifica uma unidade de E/S através de um número inteiro;
As unidades 0, 5 e 6 são reservadas para uso interno do Fortran como unidades de erro, saída e entrada padrão;
O símbolo * (asterisco) pode ser utilizado em substituição aos números que identificam as unidades padrão (0,5 e 6)
Comandos de entrada/saída de dados
PRINT: comando exclusivo para SAÍDA de dados na TELA
– Forma geral:
print *, <lista de variáveis>
ou
print <formato>, <lista de variáveis>
– Exemplo:
print *, ‘O resultado do calculo e:’
print ‘(3F10.3)’, x, y, z
print 100, x, y, z
100 format(3F10.3) ! FORMAT?! O que isso faz?
Formatação de entrada/saída
A formatação de dados permite que especifiquemos como os dados serão escritos ou lidos de uma unidade de E/S (número de casas decimais, tamanho máximo ocupado pelo dados, quebras de linhas, etc...)
A formatação de E/S é feita através do comando FORMAT ou aplicando-se a máscara de formatação diretamente ao comando de E/S utilizado
FORMAT: forma geral do comando<rótulo> format(<máscara de formatação>)
<rótulo>: número inteiro inserido nas 5 primeiras colunas do arquivo-fonte e que identifica o rótulo
<máscara de formatação>: Texto que especifica como o dado será lido/escrito
OBS: o comando format pode ser localizado em qualquer parte do corpo do programa
Máscaras de formatação
A : Texto
FORMATO ENTRADA VALOR TIPO DE DADO
A6 PAGE^# # CHARACTER(LEN=1)
A6 PAGE^# E^# CHARACTER(LEN=3)
A6 PAGE^# PAGE^# CHARACTER(LEN=6)
A6 PAGE^# PAGE^#^^ CHARACTER(LEN=8)
A6 PAGE^# # LOGICAL(1)
A6 PAGE^# ^# INTEGER(2)
A6 PAGE^# GE^# REAL(4)
A6 PAGE^# PAGE^#^^ REAL(8)
Máscaras de formatação
i : inteiro
FORMATO ENTRADA VALORI4 2788 2788I3 -26 -26I9 ^^^^^^312 312
FORMATO VALOR SAÍDAI3 284 284I4 -284 -284I4 0 ^^^0I5 174 ^^174I2 3244 **I3 -473 ***I7 29.812 An error; the decimal point is invalidI4.0 0 ^^^^I4.2 1 ^^01I4.4 1 0001
Máscaras de formatação
f: Real de precisão simples
FORMATO ENTRADA VALOR
F8.5 123456789 123.45678
F8.5 -1234.567 -1234.56
F8.5 24.77E+2 2477.0
F5.2 1234567.89 123.45
FORMATO VALOR SAÍDA
F8.5 2.3547188 ^2.35472
F9.3 8789.7361 ^8789.736
F2.1 51.44 **
F10.4 -23.24352 ^^-23.2435
F5.2 325.013 ******
F5.2 -.2 -0.20
Máscaras de formatação
d,e: Real de precisão simples e dupla em notação exponencial
FORMATO ENTRADA VALORE9.3 734.432E3 734432.0E12.4 ^^1022.43E 1022.43E-6E15.3 52.3759663^^^^^ 52.3759663E12.5 210.5271D+10¹ 210.5271E10BZ,D10.2 12345^^^^^ 12345000.0D0D10.2 ^^123.45^^ 123.45D0D15.3 367.4981763D+04 3.674981763D+06
FORMATO VALOR SAÍDAE11.2 475867.222 ^^^0.48E+06E11.5 475867.222 0.47587E+06E12.3 0.00069 ^^^0.690EE10.3 -0.5555 -0.556E+00E5.3 56.12 *****E14.5E4 -1.001 -0.10010E+0001E13.3E6 0.000123 0.123E-000003D14.3 0.0363 ^^^^^0.363D-01D23.12 5413.87625793 ^^^^^0.541387625793D+04D9.6 1.2 *********
Máscaras de formatação
ES: Notação científica
FORMATO ENTRADA VALOR
ES11.3 ^^5.321E+00 5.32100
ES11.3 -6.000E-03 -.60000
ES12.3 ^^^3.150E-03 .00315
ES12.3 ^^^3.829E+03 3829.0
FORMATO VALOR SAÍDA
ES11.2 473214.356 ^^^4.73E+05
ES11.5 473214.356 4.73214E+05
ES12.3 0.00069 ^^^6.900E-04
ES10.3 -0.5555 -5.555E-01
ES11.2 0.0 ^0.000E+00
Máscaras de formatação
EN: Notação de engenharia
FORMATO ENTRADA VALOR
EN11.3 ^^5.321E+00 5.32100
EN11.3 -600.00E-03 -.60000
EN12.3 ^^^3.150E-03 .00315
EN12.3 ^^^3.829E+03 3829.0
FORMATO VALOR SAÍDA
EN11.2 475867.222 ^475.87E+03
EN11.5 475867.222 ***********
EN12.3 0.00069 ^690.000E-06
EN10.3 -0.5555 **********
EN11.2 0.0 ^000.00E-03
Máscaras de formatação
G: Formato geral
VALOR FORMATO SAIDA COM G FORMATO SAÍDA COM F
0.01234567 G13.6 ^0.123457E-01 F13.6 ^^^^^0.012346
-0.12345678 G13.6 -0.123457^^^^ F13.6 ^^^^-0.123457
1.23456789 G13.6 ^^1.23457^^^^ F13.6 ^^^^^1.234568
12.34567890 G13.6 ^^12.3457^^^^ F13.6 ^^^^12.345679
123.45678901 G13.6 ^^123.457^^^^ F13.6 ^^^123.456789
-1234.56789012 G13.6 ^-1234.57^^^^ F13.6 ^-1234.567890
12345.67890123 G13.6 ^^12345.7^^^^ F13.6 ^12345.678901
123456.78901234 G13.6 ^^123457.^^^^ F13.6 123456.789012
-1234567.89012345 G13.6 -0.123457E+07 F13.6 *************
Máscaras de formatação
B: Formato binário
FORMATO ENTRADA VALORB4 1001 9B1 1 1B2 0 0
FORMATO VALOR SAÍDAB4 9 1001B2 0 ^0
Outros formatos importantes
X: espaços em branco
/: quebra de linha
\: continuação de linha
Comando de escrita (saída)
WRITE: comando utilizado para gravar um saída na unidade especificada com formatação ou não. O comando write possui vários parâmetros de controle, porém, neste curso só trataremos de sua forma mais básica.
Forma básica:write(unit=<unidade de saida>,fmt=<formato>)
unit = número inteiro identificando a unidadefmt = rótulo de formatação ou o símbolo * para formatação
livre
Exemplo:write(*,99) 3.1499 format(‘O valor de PI e:’,f5.2)
A seguinte saída será produzida na tela (saída padrão)O valor de PI é: 3.14
Comando de leitura (entrada)
READ: O comando read é utilizado para leitura de dados de uma unidade de entrada e possui forma básica idêntica a do comando write.
Forma básica:read(unit=<unidade de entrada>,fmt=<formato>)
unit = número inteiro identificando a unidadefmt = rótulo de formatação ou o símbolo * para formatação
livre
Exemplo:print *, ‘Entre com o valor de PI?’read(*,*) pi! O comando read direcionado para a unidade * fará com! que o programa aguarde a entrada do valor pelo teclado! (entrada padrão)
Entrada e saída de dados com arquivos
OPEN: O comando open é usado para abrir um arquivo para que ele possa ser usado em operações de leitura e/ou escrita. Assim como os comandos write e read o comando open possui várias opções, porém, só iremos tratar das suas opções mais básicas aplicadas a arquivos do tipo ASCII.
Forma geral:open(unit=<unidade>, file=<arquivo>)
unit = número inteiro identificando a unidade
file = nome do arquivo que será aberto
Exemplo:
open(11,file=‘dados.txt’)
Entrada e saída de dados com arquivos
CLOSE: O comando close, ao contrário do comando open, é usado para fechar um arquivo.
Forma geral:close(unit=<unidade>)
Curiosidades:– O Fortran é uma linguagem muito pouco exigente, ou seja, ela faz de
tudo para que os pequenos erros não interfiram na execução normal do programa. Em Fortran se uma unidade for inadvertidamente deixada aberta a própria linguagem se encarrega de fechá-la ao término do programa. O programador pode inclusive escrever em um arquivo que não foi previamente aberto. Neste caso, um arquivo com o nome fort.unit (onde unit é o numero da unidade usada na escrita) será aberto para manter o programa funcionando.
Está na hora de praticarmos
Fazer um programa que grave no arquivo fatorial.txt o fatorial dos números de 1 a 10
Avaliando o problema:– Como eu calculo o fatorial de um número? Normalmente é mais fácil pensarmos
em um exemplo simples do que em uma fórmula geral, então, tomemos como exemplo o fatorial de 3
3! = 3 x 2 x 1 ! tem cara de laço de repetição (loop)...
– A variável de controle do loop pode ser usada nos cálculos (sem que seu valor seja alterado)
– Precisarei calcular o fatorial de 10 números, ou seja, precisarei calcular o fatorial 10 vezes (tem cara de outro loop).
– O fatorial por definição será um número inteiro positivo
1-fatorial
Programa fatorial
program fatorialimplicit noneinteger :: NumberOfFactorials = 10integer :: i, j, TemporaryFactorial
open(7,file=‘fatorial.txt’)
! Este laço faz com que sejam calculados os fatoriais de 1 a NumberOfFactorialdo i=1,NumberOfFactorials ! A variavel abaixo armazena e acumula o resultado do fatorial TemporaryFactorial = 1
! Este laço calcula do fatorial de i do j=1,i TemporaryFactorial = TemporaryFactorial*j enddo write(7,9) i, TemporaryFactorial write(*,9) i, TemporaryFactorial enddoclose(7)9 format(‘O fatorial de ‘, I3, ‘ e: ‘, I10)
end program
Variáveis indexadas estáticas(desvendando os poderes do Fortran 9x)
Variáveis indexadas ou arrays: – As variáveis indexadas ou simplesmente arrays são estruturas
utilizadas para o armazenamento de dados do mesmo tipo em áreas contíguas de memória permitindo que os dados sejam acessados diretamente através de seu índice.
Os arrays estáticos ocupam um espaço fixo na memória durante TODATODA a execução do programa
Declaração e dimensionamento de arrays:
Em Fortran, a declaração de um array segue as mesmas regras de declaração de qualquer outra variável acrescentando-se (ou não) o comando dimension para especificação do numero de dimensões, limites ou tamanho do array :
integer, dimension(10) :: idx ! Forma 1 – usando dimension
integer :: idx(10) ! Forma 2 – diretamente sem usar dimension
! Forma 3 – declaração e dimensionamento separados
integer idx
dimension idx(10)
! IMPORTANTE: Array com limite inferior diferente de 1
integer, dimension(-9:9) :: idx ! Qual o tamanho de idx?
! idx armazenara 19 valores inteiros
Declarando arrays em Fortran
Mais exemplos:
! Declarando arrays que não iniciam em 1
logical :: used(-1:9) ! Armazena 11 valores lógicos
! Um array de character
character column(5)*25 ! 5 strings de 25 caracteres cada
! Com o uso de parametros constantes
integer, parameter :: nsize = 100 ! COMANDO NOVO: PARAMETER
real*8 MeuArray(nsize)
OBS: Os parametros designam valores constantes para o programa, ou seja, eles nunca poderão ser modificados em tempo de execução.
Note que em qualquer lugar do programa onde estiver escrito nsize sub-entende-se que está escrito o seu valor: 100.
Variáveis indexadas - Terminologia
Posto: – O posto (rank) de uma matriz é o número de dimensões da mesma. Assim, um
escalar tem posto 0, um vetor tem posto 1 e uma matriz tem posto maior ou igual a 2
Extensão: – A extensão (extent) de uma matriz se refere a uma dimensão em particular e é o
número de componentes naquela dimensão
Forma: – A forma (shape) de uma matriz é um vetor cujos componentes são a extensão
de cada dimensão da matriz.
Tamanho: – O tamanho (size) de uma matriz é o número de elementos que compõe a matriz.
Este número pode ser zero, em cujo caso denomina-se matriz nula
Terminologia na prática
real*4, dimension(-3:4,7) :: a
A matriz “a” declarada acima possui: – Posto 2– Extensão 8 e 7– Forma (/8,7/) ! Os símbolos “/” são arrays constructors– Tamanho 56
a(-3,1) a(-3,2) a(-3,3) a(-3,4) a(-3,5) a(-3,6) a(-3,7)
a(-2,1) a(-2,2) a(-2,3) a(-2,4) a(-2,5) a(-2,6) a(-2,7)
a(-1,1) a(-1,2) a(-1,3) a(-1,4) a(-1,5) a(-1,6) a(-1,7)
a( 0,1) a( 0,2) a( 0,3) a( 0,4) a( 0,5) a( 0,6) a( 0,7)
a( 1,1) a( 1,2) a( 1,3) a( 1,4) a( 1,5) a( 1,6) a( 1,7)
a( 2,1) a( 2,2) a( 2,3) a( 2,4) a( 2,5) a( 2,6) a( 2,7)
a( 3,1) a( 3,2) a( 3,3) a( 3,4) a( 3,5) a( 3,6) a( 3,7)
a( 4,1) a( 4,2) a( 4,3) a( 4,4) a( 4,5) a( 4,6) a( 4,7)
Iniciando Arrays
! 1) Na declaração e com valor constante
integer, dimension(-10,10) :: idx = 1
! 2) Na declaração e com loop implicito
integer :: idx(10) = (/(2*i,i=1,10)/)
! 3) Na declaração e com valores explicitamente indicados
integer :: idx(3) = (/-1,-2,-3/)
! 4) No corpo do programa, atribuindo valores diretamente:
idx = 3 ! ou idx(:) = 3
! 5) No corpo do programa com um loop explicito (forma F77)
do i=-10,10
idx(i) = i
enddo
! 6) No corpo do programa usando a seleção de alguns trechos
idx(-10:1) = 99
idx(0) = 0
idx(1:10) = -99
Iniciando Arrays (continuação)
! 7) Com dados lidos de algum lugar (arquivo ou tela) em loop explicitodo i=-10,10
read(iunit,*) idx(i)enddo
! 8) Com dados lidos de algum lugar (arquivo ou tela) em loop implicitoread(iunit,*) (idx(i),i=-10,10)
! 9) Com dados lidos de algum lugar (arquivo ou tela) diretamenteread(iunit,*) idx(:) ! ou simplesmente “idx” sem o (:)
! 10) Com dados lidos de algum lugar (arquivo ou tela) por trechosread(iunit,*) idx(-10:0)read(iunit,*) idx(0)read(iunit,*) idx(1:10)
! 11) Atribuicao em arrays de dimensoes e formas diferentesreal*4, dimension(15,5) :: a1 = 10.0real*4, dimension( 5) :: a2! a2 recebera o conteudo das linhas 1 a 5 da coluna 2 de a1a2(:) = a1(1:5,2)
2-IniciandoArrays
Iniciação de arrays (continuação)
Suponha a seguinte matriz:
Qual das formas abaixo seria correta para iniciá-la durante sua declaração?
integer, dimension(2,3) :: idx = (/1,2,3,1,2,3/)
integer, dimension(2,3) :: idx = (/1,1,2,2,3,3/)
RESPOSTA:
A segunda opção é a correta pois o Fortran armazena os arrays por coluna, vejam no próximo slide o que isso significa na prática...
Como o Fortran armazena arrays na memória?
integer :: idx(2,3) = (/1,2,3,1,2,3/)integer :: idx(2,3) = (/1,1,2,2,3,3/)
Fortran (por colunas) C/C++ e Pascal (por linhas)
idx(1,1) idx(1,2) idx(1,3)
idx(2,1) idx(2,2) idx(2,3)
idx(1,1) idx(1,2) idx(1,3)
idx(2,1) idx(2,2) idx(2,3)
Acessando matrizes eficientemente em Fortran
Qual seria a forma mais adequada de acessar a matriz “idx”?
do i=1,2
do j=1,3
idx(i,j) = j
enddo
enddo
do j=1,3
do i=1,2
idx(i,j) = j
enddo
enddo
OU
idx(1,1) idx(1,2) idx(1,3)
idx(2,1) idx(2,2) idx(2,3)
idx(1,1) idx(1,2) idx(1,3)
idx(2,1) idx(2,2) idx(2,3)
Acessando dados em um array
real*8 :: a(6,6)
a(2,3) ! Elemento na linha 2 e coluna 3
a(:,:) ! Matriz inteira
a(2,:) ! Todos os elementos da linha 2
a(:,3) ! Todos os elementos da coluna 3
a(1:3,2) ! 3 primeiras linhas da coluna 2
a(2,3:5) ! a(2,3), a(2,4), a(2,5)
a(1:6:2,1:6:2) ! a(1,1), a(1,3), a(1,5)
! a(3,1), a(3,3), a(3,5)
! a(5,1), a(5,3), a(5,5)
Acessando dados em um array
a(2,3)
a(:,:)
a(2,:)
a(:,3)
a(1:3,2)
a(2,3:5)
a(1:6:2,1:6:2)
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
1,1 1,2 1,3 1,4 1,5 1,6
2,1 2,2 2,3 2,4 2,5 2,6
3,1 3,2 3,3 3,4 3,5 3,6
4,1 4,2 4,3 4,4 4,5 4,6
5,1 5,2 5,3 5,4 5,5 5,6
6,1 6,2 6,3 6,4 6,5 6,6
Operações com arrays (Fortran90)
O Fortran90 tornou possível que as operações com arrays, que anteriormente só eram possíveis através do uso de laços, passassem a ser efetuadas exatamente da mesma forma como se faz para uma variável escalar.
real*8, dimension(10,10) :: array1 = 1.d0real*8, dimension(10,10) :: array2 = 3.3d0real*8, dimension(10,10) :: array3
! Em F90 podemos fazer:array3(:,:) = array1(:,:)+array2(:,:)! ou simplesmente: array3 = array1+array2! O uso do (:,:) é desnecessário mas aconselhável pois ajuda! a distinguir o que é um array do que é um escalar
! Em F77 teríamos de fazer:do i=1,10 do j=1,10 array3(j,i) = array1(j,i)+array2(j,i)
enddoenddo
Programa-exemplo: Subtraindo 2 arrays
program SomaMatrizes
integer, parameter :: n=3
real*8 :: mat1(n,n) = 1.5d0
real*8 :: mat2(n,n) = 0.5d0
real*8 :: mat3(n,n)
! subtrai mat2 de mat1 e armazena o resultado em mat3
mat3 = mat1+mat2
do i=1,n
print *, '[', mat3(i,1:n), ' ]'
enddo
end program
3-SomaMatriz
arrays e Funções intrínsecas (Fortran90)
As funções intrínsecas do Fortran90 operam em arrays da mesma forma que operam em escalares
real*8, dimension(3,3) :: array1 = -1.d0
array1 = dabs(array1) ! array1 fica igual a 1.d0
array1 = array1 - 2.d0 ! array1 volta a ser -1.d0
array1 = dacos(array1) ! array1 fica igual a PI
4-FuncoesIntrinsecas
Comandos condicionais específicos para arrays
O Fortran90 assimilou alguns comandos condicionais específicos para tratamento de arrays, são eles: where e forall
WHERE: Aplica uma operação lógica a todo o conteúdo de um array simultaneamente.
integer, dimension(5) :: iarray = (1,0,-1,3,2)
logical, dimension(5) :: flag = .false.
teste: where (iarray<0)
flag = .true.
elsewhere
flag = .false.
end where teste
! como o vetor flag foi previamente iniciado poderiamos fazer:
where(iarray<0) flag =.true. ! flag resultara em (F,F,T,F,F)
Comandos condicionais específicos para arrays
FORALL: Este comando foi incluído ao padrão Fortran95 e é uma generalização do comando wherereal, dimension(10,10) :: array = 0.0
forall (i=1:5)
array(i,i) = 1.0
end forall
! Repare que o exemplo acima poderia ser feito com a atribuição direta:
array(1:5,1:5)=1.0
! Entao vamos fazer algo mais ilustrativo...
real, dimension(3,3) :: array = (/1.,-.5,2.,0.,3.5,.7,1.3,0.,-1.4/)
array = sqrt(array)
! * * * DARA ERRO DE EXECUCAO DEVIDO AOS VALORES NEGATIVOS * * *
! Vamos usar o comando FORALL para realizar a inversao com segurança
FORALL (i=1:3,j=1:3, array(i,j) > 0.)
array(i,j) = sqrt(array(i,j))
END FORALL
obs: geralmente o comando FORALL pode ser escrito na forma de uma série de laços DO associados com blocos condicionais IF
5-FORALL
Funções específicas para arrays (Fortran90)
maxval : Retorna o maior valor
minval : Retorna o menor valor
minloc : Retorna a posição do menor valor
maxloc : Retorna a posição do maior valor
sum : Retorna o somatório de todos os termos
count : Retorna o número de valores verdadeiros
all : Verifica se todos os valores de um array são verdadeiros
any : Verifica a existência de qualquer valor verdadeiro em um array
reshape : Modifica a forma (shape) de um array
transpose : Transpõe um array de posto (rank) 2
matmul : Multiplicação de matrizes
dot_product : produto escalar de 2 arrays de posto 1
pack : Extrai elementos de um array baseado em uma máscara e retorna o resultado
em um array de posto 1
unpack : Injeta elementos de um array de posto 1 em um array de posto superior
baseado em uma máscara
Programa-exemplo: Usando funções de arraysprogram ArrayFunctions
integer, parameter :: n = 9
real*4 , dimension(n) :: a = (/-.84,.95,.53,-.48,-.79,.98,-.51,.49,-.75/)
logical, dimension(n) :: b = .false.
vmin = minval(a) ! extrai o valor minimo de a
vmax = maxval(a) ! extrai o valor maximo de a
asum = sum(a) ! soma todos os valores de a
where (a.lt.0.0) b = .true. ! atribui verdadeiro as posicoes de b onde a<0
nlt1 = count(b) ! conta quantos valores de "a" sao < 0)
write(*,'(1x,a4,7x,a5)') 'a', 'a<0.0‘
write(*,'(20("="))')
write(*,5) ((a(i),b(i)),i=1,n)
write(*,'(20("="))')
write(*,*) ' valor minimo:', vmin, ' na posicao:', minloc(a)
write(*,*) ' valor maximo:', vmax, ' na posicao:', maxloc(a)
write(*,*) ' Soma de todos os valores do vetor a:', asum
write(*,*) ' Numero de valores de a < 0.0:', nlt1
5 format('[',F4.2, '] --> [',l5, ']')
end program
6-ArrayFunctions
Mais um programa-exemplo para praticarmos...
Dadas as seguintes matrizes e vetores:
Utilizar funções intrínsecas matmul, transpose e dot_product do F90 para realizar as seguintes operações:
OBS: Não esquecer da compatibilidade de dimensões...
; ;
1.3 -1.1 -0.5 -1.4 0.5 -1.2 0.3A B d
2.1 0.2 -0.9 0.3 0.0 3.2 0.9
program MultiplicaMatrizesreal*4 :: A(2,3), tmp(2,3), B(3,2) real*4 :: C(2,2) ! armazenara o resultado de AxBreal*4 :: d( 2) = (/0.3,0.9/)real*4 :: e( 2) ! armazenara o resultado de Cxddata a / 1.3, 2.1, -1.1, 0.2, -0.5, -0.9/data tmp /-1.4, 0.3, 0.5, 0.0, -1.2, 3.2/
C = matmul(A, B) ! Para a multiplicacao ser possivel temos de transpor Be = matmul(C,d)dot = dot_product(e,d)b = transpose(tmp)
! ESTA PARTE SO FOI INSERIDA PARA IMPRESSAO DOS RESULTADOS...write(*,1) A(1,1:3),B(1,1:2),C(1,1:2)write(*,2) A(2,1:3),B(2,1:2),C(2,1:2)write(*,3) B(3,1:2)
write(*,4) C(1,1),C(1,2),d(1),e(1)write(*,5) C(2,1),C(2,2),d(2),e(2)
write(*,6) e(1),e(2),d(1),dotwrite(*,7) d(2)
1 format(/"PRODUTO MATRICIAL DE A x B^T",//& "[", 3(1x,f5.2,1x), "] [", 2(1x,f5.2,1x), "] [", 2(1x,f5.2,1x), "]")2 format( "[", 3(1x,f5.2,1x), "] X [", 2(1x,f5.2,1x), "] = [", 2(1x,f5.2,1x), "]")3 format( 1x, 21x , " [", 2(1x,f5.2,1x), "]"/)4 format(/"PRODUTO ENTRE A MATRIZ C E O VETOR e",//& "[", 2(1x,f5.2,1x), "] X [", (1x,f5.2,1x), "] = [", (1x,f5.2,1x), "]" )5 format( "[", 2(1x,f5.2,1x), "] [", (1x,f5.2,1x), "] [", (1x,f5.2,1x), "]"/ )6 format(/"PRODUTO ESCALAR ENTRE OS VETORES e e d",//& "[",2(1x,f5.2,1x),"] X [", (1x,f5.2,1x), "] = ", (1x,f5.2) )7 format( 1x, 14x," [", (1x,f5.2,1x), "] " )
end program7-MultiplicaMatrizes
Exercício proposto para a próxima aula
Fazer um programa que calcule as coordenadas dos nós de uma grade e grave as coordenadas obtidas em um arquivo de texto.
O programa deverá conter as seguintes linhas iniciais:
program Grade
real*8, parameter :: xmin = 0.d0 &
ymin = 0.d0 &
xmax = 10.d0 &
ymax = 10.d0 &
dx = 2.d0 &
dy = 2.d0
real*8, allocatable(:,:) :: xyz
! Desenvolva o algoritmo aqui
End program
Alocação Dinâmica de Memória
A alocação dinâmica de memória foi um grande avanço no Fortran a partir do padrão Fortran90 pois permitiu um uso mais racional da memória do sistema;
A alocação dinâmica de memória permite ao programador decidir pela requisição de uma quantidade de memória para uso em arrays somente quando esta se faz, realmente, necessária;
Tal recurso também viabilizou a compilação e execução de programas; que antes se utilizavam de alocação estática e que não eram viáveis devido ao excessivo consumo de memória; em computadores com disponibilidade de recursos limitado;
A tarefa de gerenciamento de memória em Fortran77 era árdua e normalmente feita através da manipulação explícita de grandes áreas de memória estaticamente alocadas. Tais áreas eram mutuamente utilizadas por arrays de tipos distintos e frequentemente era necessária alguma operação de manutenção dos espaços vazios deixados. Além disso, o programador tinha de se certificar que a alocação estática assumida era suficiente para o programa rodar.
Uma outra limitação da alocação estática era a necessidade de recompilação do programa a cada vez que a quantidade de memória requerida fosse diferente daquela existente no programa. Isso pode parecer algo simples para programas caseiros, mas imaginem um programa comercial tendo que ser recompilado simplesmente porque necessitou de mais memória.
Alocação Dinâmica de Memória - Curiosidades
Quanto representa a memória do computador para um programa? Para respondermos a essa pergunta, vamos fazer algumas considerações:
– Suponha um computador com 1Gb de memória e que 100% desta memória estará disponível para o nosso programa.
– Suponha também que o programa só utilizará números reais de precisão dupla, então:1 GBytes = 1024 MBytes = 10242 KBytes = 10243 Bytes
se 1 número real de dupla precisão consome 16 bytes, então:10243/16 = 67108864 números reais de precisão dupla
Parece muito... mas o quanto isso equivale em relação a um array quadrado?671088641/2 = 8192
CONCLUSÃO: O tamanho máximo do array, neste caso, seria:real*8, dimension(8192,8192) :: array
Obviamente que nosso programa não terá 100% da memória disponível
É óbvio também que a alocação dinâmica não soluciona esse problema, mas ajuda a amenizá-lo, pois a memória pode ser alocada e desalocada de acordo com a necessidade do programa;
Alocação dinâmica e seus comandos
Os comandos associados a alocação dinâmica de memória em Fortran90 são:
– allocatable : específica que um array pode ser dinamicamente alocado durante a execução do programa;
– allocate : comando utilizado no ato de alocação de memória;
– deallocate: comando utilizado para desalocar, e consequentemente, devolver a memoria para o sistema;
– allocated : verifica se um array está alocado ou não
Declarando arrays alocáveis
ALLOCATABLE: O comando allocatable é usado na declaração de um array para designar que o mesmo poderá ser dinâmicamente alocado durante a execução do programa.
! Forma 1: shape no nome da variavelreal*8, allocatable :: arr1(:,:)
! Forma 2: shape no comando allocatablereal*8, allocatable(:,:) :: arr1
! Forma 3: shape no comando dimensionreal*8, allocatable, dimension(:,:) :: arr1
! As formas 2 e 3 são uteis quando se deseja declarar! vários arrays alocaveis com o mesmo shape
Alocando arrays alocáveis
ALLOCATE: O comando allocate efetivamente faz a requisição de memória do sistema para que possa ser usada pelo array.
Forma geral:
allocate( <lista de arrays>, stat=<istatus> )
<lista de arrays>: um ou mais arrays que se deseja alocar juntamente com o tamanho do array.
<istatus> (OPCIONAL): Inteiro que retorna o valor 0 se o array for alocado com sucesso e maior que zero em caso de erro
! Exemplo: alocando 3 vetoresreal*8, allocatable(:) :: a, b, cn = 1000allocate(a(n),b(n),c(n),stat=ierr)if (ierr.ne.0) print *, ‘Erro ‘, ierr, ‘ na alocacao de memoria’
Alocando arrays alocáveis
Outros exemplos:
real*8, allocatable(:) :: arr1, arr2, arr3, arr4, arr5
print *, ‘ Entre com o tamanho do vetor arr1:’
read(*,*) n
allocate(arr1(n)) ! A partir desse ponto o vetor arr1 pode ser usado
allocate(arr2(1000)) ! alocacao com tamanho explicito
allocate(arr3(-100:100)) ! alocacao com indice inicial diferente de 1
allocate(arr4(10),stat=i) ! alocacao com verificacao
if (i.ne.0) print *, ‘ Algum problema ocorreu...’
allocate(arr5(0)) ! alocacao de array nulo.
Desalocando arrays previamente alocados
DEALLOCATE: O comando Deallocate devolve a memória utilizada por um array desalocando-o da memória.
Forma geral:
deallocate( <lista de arrays>, stat=<istatus> )
<lista de arrays>: um ou mais arrays que se deseja alocar
<istatus> (OPCIONAL): Inteiro que retorna o valor 0 se o array for alocado com sucesso e maior que zero em caso de erro
! Exemplo: desalocando 3 vetores simultaneamente
deallocate(a,b,c,stat=ierr)
if (ierr.eq.0) ‘ Arrays desalocados com sucesso...’
Verificando se um array está alocado
ALLOCATED: O comando allocated é utilizado para verificar o status de alocação de um array e é normalmente utilizado em associação com o comando allocate. O comando retorna .true. caso o array esteja alocado e .false. caso contário.
Forma geral:
allocated(<array>)
! Exemplo: desalocando 3 vetores simultaneamente
real*8, allocatable(:,:) :: arr1
! so aloca a matriz arr1 caso ela NAO esteja alocada
if (.not.allocated(arr1)) allocate(arr1(-10:10))
! so desaloca a matriz arr1 caso ela esteja alocada
if (allocate(arr1)) deallocate(arr1)
Programa-exemplo
Ler os dados do seguinte arquivo e armazená-los em um array devidamente alocado:
arquivo dados.txt10 3
-3.13 -8.31 0.25
-7.32 -4.43 9.86
-7.44 1.65 3.53
-6.35 9.87 4.24
1.56 -5.45 2.84
-0.54 -3.67 5.73
7.05 -9.53 -5.25
-1.80 -1.82 3.38
8.98 6.84 9.96
6.57 -2.82 -0.84
program MemoryAllocation
real*4, allocatable :: a(:,:)
open(9,file="dados.txt")
read(9,*) n1, n2
if (.not.allocated(a)) then
allocate(a(n1,n2))
endif
do i=1,n1
read (9,*) (a(i,j),j=1,n2)
write(*,*) (a(i,j),j=1,n2)
enddo
close(9)
end program
8-Alocacao