CPC782 Fundamentos de Programação

Apresentação em tema: "CPC782 Fundamentos de Programação"— Transcrição da apresentação:

1 CPC782 Fundamentos de Programação
Introdução ao Fortran aula 2/3 Renato N. Elias / Marcos A. D. Martins material disponível em:

2 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

3 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

4 Aula 2 Comandos de Entrada e Saída (E/S) Variáveis indexadas
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

5 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

6 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)

7 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? 

8 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

9 Máscaras de formatação
A : Texto FORMATO ENTRADA VALOR TIPO DE DADO A PAGE^# # CHARACTER(LEN=1) A PAGE^# E^# CHARACTER(LEN=3) A PAGE^# PAGE^# CHARACTER(LEN=6) A PAGE^# PAGE^#^^ CHARACTER(LEN=8) A PAGE^# # LOGICAL(1) A PAGE^# ^# INTEGER(2) A PAGE^# GE^# REAL(4) A PAGE^# PAGE^#^^ REAL(8)

10 Máscaras de formatação
i : inteiro FORMATO ENTRADA VALOR I I I ^^^^^^ FORMATO VALOR SAÍDA I I I ^^^0 I ^^174 I ** I *** I An error; the decimal point is invalid I ^^^^ I ^^01 I

11 Máscaras de formatação
f: Real de precisão simples FORMATO ENTRADA VALOR F F F E F FORMATO VALOR SAÍDA F ^ F ^ F ** F ^^ F ****** F

12 Máscaras de formatação
d,e: Real de precisão simples e dupla em notação exponencial FORMATO ENTRADA VALOR E E E ^^ E E-6 E ^^^^^ E D+10¹ E10 BZ,D ^^^^^ D0 D ^^123.45^^ D0 D D D+06 FORMATO VALOR SAÍDA E ^^^0.48E+06 E E+06 E ^^^0.690E E E+00 E ***** E14.5E E+0001 E13.3E E D ^^^^^0.363D-01 D ^^^^^ D+04 D *********

13 Máscaras de formatação
ES: Notação científica FORMATO ENTRADA VALOR ES ^^5.321E ES E ES ^^^3.150E ES ^^^3.829E FORMATO VALOR SAÍDA ES ^^^4.73E+05 ES E+05 ES ^^^6.900E-04 ES E-01 ES ^0.000E+00

14 Máscaras de formatação
EN: Notação de engenharia FORMATO ENTRADA VALOR EN ^^5.321E EN E EN ^^^3.150E EN ^^^3.829E FORMATO VALOR SAÍDA EN ^475.87E+03 EN *********** EN ^ E-06 EN ********** EN ^000.00E-03

15 Máscaras de formatação
G: Formato geral VALOR FORMATO SAIDA COM G FORMATO SAÍDA COM F G ^ E F ^^^^^ G ^^^^ F ^^^^ G ^^ ^^^^ F ^^^^^ G ^^ ^^^^ F ^^^^ G ^^ ^^^^ F ^^^ G ^ ^^^^ F ^ G ^^ ^^^^ F ^ G ^^ ^^^^ F G E F *************

16 Máscaras de formatação
B: Formato binário FORMATO ENTRADA VALOR B B B FORMATO VALOR SAÍDA B B ^0 Outros formatos importantes X: espaços em branco /: quebra de linha \: continuação de linha

17 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 unidade fmt = rótulo de formatação ou o símbolo * para formatação livre Exemplo: write(*,99) 3.14 99 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

18 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 unidade fmt = 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)

19 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’)

20 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.

21 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

22 Programa fatorial program fatorial implicit none
integer :: NumberOfFactorials = 10 integer :: i, j, TemporaryFactorial open(7,file=‘fatorial.txt’) ! Este laço faz com que sejam calculados os fatoriais de 1 a NumberOfFactorial do 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 close(7) 9 format(‘O fatorial de ‘, I3, ‘ e: ‘, I10) end program

23 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 TODA a execução do programa

24 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

25 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.

26 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

27 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

28 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

29 Iniciando Arrays (continuação)
! 7) Com dados lidos de algum lugar (arquivo ou tela) em loop explicito do i=-10,10 read(iunit,*) idx(i) enddo ! 8) Com dados lidos de algum lugar (arquivo ou tela) em loop implicito read(iunit,*) (idx(i),i=-10,10) ! 9) Com dados lidos de algum lugar (arquivo ou tela) diretamente read(iunit,*) idx(:) ! ou simplesmente “idx” sem o (:) ! 10) Com dados lidos de algum lugar (arquivo ou tela) por trechos read(iunit,*) idx(-10:0) read(iunit,*) idx(0) read(iunit,*) idx(1:10) ! 11) Atribuicao em arrays de dimensoes e formas diferentes real*4, dimension(15,5) :: a1 = 10.0 real*4, dimension( 5) :: a2 ! a2 recebera o conteudo das linhas 1 a 5 da coluna 2 de a1 a2(:) = a1(1:5,2) 2-IniciandoArrays

30 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...

31 Como o Fortran armazena arrays na memória?
Fortran (por colunas) C/C++ e Pascal (por linhas) integer :: idx(2,3) = (/1,1,2,2,3,3/) integer :: idx(2,3) = (/1,2,3,1,2,3/)

32 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 do j=1,3 do i=1,2 idx(i,j) = j enddo OU

33 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)

34 Acessando dados em um array

35 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.d0 real*8, dimension(10,10) :: array2 = 3.3d0 real*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) enddo

36 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

37 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

38 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)

39 Comandos condicionais específicos para arrays
FORALL: Este comando foi incluído ao padrão Fortran95 e é uma generalização do comando where real, 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

40 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

41 Programa-exemplo: Usando funções de arrays
program 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(*,*) ' 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

42 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...

43 ! ESTA PARTE SO FOI INSERIDA PARA IMPRESSAO DOS RESULTADOS...
program MultiplicaMatrizes real*4 :: A(2,3), tmp(2,3), B(3,2) real*4 :: C(2,2) ! armazenara o resultado de AxB real*4 :: d( 2) = (/0.3,0.9/) real*4 :: e( 2) ! armazenara o resultado de Cxd data 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 B e = 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),dot write(*,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, x , " [", 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, x," [", (1x,f5.2,1x), "] " ) end program 7-MultiplicaMatrizes

44 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

45 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.

46 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 = KBytes = Bytes se 1 número real de dupla precisão consome 16 bytes, então: 10243/16 = números reais de precisão dupla Parece muito... mas o quanto isso equivale em relação a um array quadrado? /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;

47 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

48 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 variavel real*8, allocatable :: arr1(:,:) ! Forma 2: shape no comando allocatable real*8, allocatable(:,:) :: arr1 ! Forma 3: shape no comando dimension real*8, allocatable, dimension(:,:) :: arr1 ! As formas 2 e 3 são uteis quando se deseja declarar ! vários arrays alocaveis com o mesmo shape

49 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 vetores real*8, allocatable(:) :: a, b, c n = 1000 allocate(a(n),b(n),c(n),stat=ierr) if (ierr.ne.0) print *, ‘Erro ‘, ierr, ‘ na alocacao de memoria’

50 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.

51 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...’

52 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)

53 Programa-exemplo Ler os dados do seguinte arquivo e armazená-los em um array devidamente alocado: arquivo dados.txt 10 3 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