Fiscomp FA-03 2011-1

Instituto de Fsica Armando Dias Tavares
Departamento de Fsica Aplicada e Termodinmica

Fsica Computacional A
DFAT/ FiscompFA
Matriz e Iterao
Professor: Anibal Leonardo Pereira ltima atualizao: maro 2011
Estagirios:
2004/1 a 2005/2 Luciana Conceio Iecker Lima
2010/1 Magali dos Santos Leodato
2009/1 a 2010/2 Filipe da Fonseca Cordovil
Monitores:
2001/1 Diego Chagas Garcia
2002/2 Erick Azevedo Meirelles
2003/1 a 2003/2 Luciana Maria dos Santos Azevedo
2003/1 a 2003/2 Tatiana Gonalves Martins
2003/1 a 2005/2 Renato Nascente Jnior
2004/1 a 2005/2 Pblio Martins Romano M. Carreiro
2006/1 a 2007/2 Luiz Fernando Rosalba Telles Souza
2006/1 a 2007/2 Paulo Henrique Pfitzner
2008/1 a 2008/2 Filipe da Fonseca Cordovil
2008/1 a 2009/2 Magali dos Santos Leodato
2011/1 a Filipe da Fonseca Cordovil
1. Introduo
A capacidade de definir vrias entidades, todas do mesmo tipo, usando um nico nome, tanto quanto a
capacidade de individualizar cada uma destas entidade criadas para que se possa trabalhar com cada uma delas
individualmente importante. O conjunto de entidades assim identificados chamado de matriz e cada um dos
itens da matriz (cada componente, cada uma das entidade que a compe) chamado de elemento da matriz.
Por exemplo, considere uma matriz unidimensional chamada veloc composta de cinco elementos, todos do tipo
real. Os elementos desta matriz unidimensional so identificados assim: veloc(1), veloc(2), veloc(3),
veloc(4) e veloc(5).
Os elementos de uma matriz so identificado escrevendo-se o nome da matriz seguido do subscrito ou
subscritos (ndices) entre parnteses. Por exemplo, se X e Y so duas matrizes unidimensionais a identificao de um
elemento nestas matrizes pode ser feito assim:
X(3) identifica o terceiro elemento da matriz X
Y(i+2) a expresso i+2 avaliada (tem que ser um inteiro) e ento usada como
ndice que identifica o elemento da matriz Y (exemplo: se i+2=4 o quarto
elemento da matriz Y referenciado)
2. Declarando uma Matriz
A declarao de uma matriz se faz utilizando o atributo dimension, na declarao de tipo da varivel.
A forma geral para se declarar uma matriz : tipo,DIMENSION(extenso)::lista-matrizes
2 DFAT/Folha Atividades/FiscompFA Matriz e Iterao
O programa matriz_01 define duas matrizes: A e B. A matriz A uma matriz de rank dois, uma matriz
bidimensional enquanto a matriz B uma matriz de rank um, portanto uma matriz unidimensional, ambas do tipo
real.

program matriz_01
!-------------------------------------------
!Programa exemplo de matriz
! AUTOR: Anibal L. Pereira 11/04/2010
!Revises: Anibal L. Pereira 15/02/2011
!
!-------------------------------------------
implicit none
real, dimension(2,2):: A
real, dimension(3) :: B
!
!--- especificando os valores da matriz A
A(1,1) = 1.1
A(1,2) = 2.2
A(2,1) = 3.5
A(2,2) = 3.9
!--- entrando com os valores na matriz unidimensional B
B(1) = 5.0
B(2) = 4.4
B(3) = 8.3
!--- mostrando o contedo do elemento (2,1) da matriz A e elemento 1 da matriz B
print"(a,f4.1)","A(2,1) = ", A(2,1)
print"(a,f4.1)","B(1) = ", B(1)
end program matriz_01
Por este programa, a matriz A fica definida assim: A=
1.1 2.2
3.5 3.9
enquanto a matriz unidimensional B fica

assim: B=(5.0, 4.4, 8.3)
A declarao: real, dimension(30):: a, b, c
especifica (declara) trs matrizes unidimensionais do tipo real a, b e c cada um deles com 30 elementos.
3. Subscrito
O ndice da matriz (o subscrito da matriz), obrigatoriamente, um valor inteiro que possibilita a identificao de
um elemento da matriz.
Na declarao de uma matriz, por default, o ndice inicia em 1, mas se especificado, pode iniciar em outro valor.
A faixa utilizada num subscrito especificada escrevendo-se o limite-inferior (lower-bound) e o limite-superior
(upper-bound) explicitamente, separados por dois pontos ( :: ).
Ento,
real, dimension(3) :: a ! por no especificar os limites 3 elementos
real, dimension(2:5) :: b
real, dimension(0:5) :: c
real, dimension(-20:-15):: d
as matrizes unidimensionais b, c e d contendo os seguintes elementos:
b(2) b(3) b(4) b(5) ! 4 elementos
c(0) c(1) c(2) c(3) c(4) c(5) ! 6 elementos
d(-20) d(-19) d(-18) d(-17) d(-16) d(-15) ! 6 elementos
DFAT/Folha Atividades/FiscompFA Matriz e iterao 3
Observe que tantos valores negativos quanto valores positivos podem ser utilizados no subscrito desde que os
subscritos (ndices) sejam valores inteiros.
4. Manipulando os Elementos da Matriz
Uma construo muito utilizada para trabalhar com os elementos de uma matriz a construo DO. Esta
construo implementa um processo de repetio (iterao), ou seja, ele repete um conjunto de aes tantas vezes
quanto for desejado ou necessrio.
5. Matriz Termos importantes
Dimension
Dimenso: o Fortran permite o uso de matrizes com at 7 dimenses (7 subscrito). Para cada dimenso existe 2
limites que definem a faixa de valores da dimenso: lower bound (limite inferior) e upper bound (limite
superior). As declaraes abaixo so similares, porque no sendo utilizado, o limite inferior, este assumido
ser unitrio:
real, d(3, 3)
real, d(1:3, 1:3)
Extent
Extenso: nmero de elementos em uma dimenso.
igual a: (upper bound - lower bound) para uma dimenso.
As duas matrizes tm extenso igual a 10 em cada dimenso:
real, d(10, 10)
real, d(-10:-1, 10:19)
usar ndice negativo em matrizes cria um ambiente inspito, mas as vezes necessrio. A dimenso
especificada por (-10: -1) corresponde aos ndices -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, que so 10 elementos.
Observe que os valores (10:19) tambm especifica 10 elementos (10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
Rank
nmero de dimenses da (nmero de subscritos utilizados na) matriz
Size
Tamanho: nmero total de elementos existentes na matriz. Para uma dimenso o nmero de elementos
definido pela diferena entre o limite superior e o limite inferior
Shape
Forma: determinada pelo nmero de dimenses e extenso em cada dimenso (rank e extent) da matriz.
A forma (shape) da matriz guardada numa matriz unidimensional onde o valor de cada elemento representa a
extenso (extent) de cada dimenso (na ordem em que aparecem).
Conformable
Matriz Conforme: duas matrizes so conformes (conformables) quando elas possuem a mesmo nmero de
subscritos (mesmo rank) e mesma quantidade de elementos em cada dimenso (mesma extenso), isto , mesma
forma (same shape).
Um escalar sempre conforme com qualquer matriz.
Importante: Todas operaes intrnsecas do Fortran so definidas entre objetos conformes.
Matriz de forma explcita
Uma matriz definida de forma que o nmero de dimenso (rank) e os tamanhos em cada dimenso (extenso)
so especificados (determinada) na sua declarao chamada de matriz de forma explcita
explicit-shape-array.
6. Entrando valores elemento a elemento numa Matriz
Como dito, possvel caracterizar cada elemento de uma matriz individualmente e trabalhar com ele
individualmente.
Os elementos de uma matriz so especificados pelo nome da matriz seguido pelos ndices (subscritos) entre
parnteses. Ento, para uma matriz A definida assim: real, dimension(2,2):: A
admitindo que a matriz A contem os valores A=
3.1 4.2
5.4 8.9
, o elemento(1,1) da matriz A guarda o valor 3.1 e

este valor pode ser acessado usando-se: A(1,1)
Exemplo:
program matriz_02
!-------------------------------------------
!Soma de dois elementos da matriz
!AUTOR: Anibal L. Pereira 11/04/2010
!-------------------------------------------
implicit none
!
!--- entrando com valores na matriz A
A(1,1) = 3.1
A(1,2) = 4.2
A(2,1) = 5.4
A(2,2) = 8.9
!--- sada no formatada
print*
print*,"Soma de A(2,2) + A(1,2)= ", A(2,2) + A(2,1)
!--- sada formatada
print*
print"(a,f4.1)","Soma de A(2,2) + A(1,2)= ", A(2,2) + A(2,1)
print*
end program matriz_02
7. Processo Iterativo
Iterao um processo repetitivo, isto , um processo que possu a capacidade de repetir uma sequncia de
instrues um nmero de vezes pr-determinada ou ento at que uma certa condio seja satisfeita.
No confundir processo iterativo com processo interativo.
Processo interativo
Na Fsica:
Interao a ao de um objeto fsico sobre outro
Extenso do conceito:
Alm da interao puramente fsica, o termo tambm caracteriza a ao conjunta
humano-humano, humano-mquina e mquina-mquina
De forma simples, ocorre uma interao quando a ao um objeto (pessoa ou mquina)
desencadeia uma reao em outro objeto (humano ou no).
Processo iterativo
Iterao o processo de repetio de uma ou mais aes
Uma iterao criada usando uma construo do. Usualmente a construo DO simplesmente chamada de
DO ou ento de loop (as vezes: Do loop).
As instrues EXIT e CYCLE podem ser utilizadas para modificar a execuo da construo DO (loop).
Sequncia de execuo
Todo programa inicia sua execuo na primeira instruo existente no cdigo fonte que define o programa e
depois, sequencialmente, vai executando as outras instrues e construes existentes nos cdigos fontes.
Esta forma sequencial de executar o programa pode ser alterada (controlada) por construes executveis
contendo blocos e por certas instrues executveis que alteram a sequncia de execuo do programa.
Construes executveis contendo blocos
As principais construes executveis que possuem blocos so:
construo DO
construo IF
construo CASE
Bloco
Um bloco um conjunto de instrues tratada como uma unidade. Os blocos so usados nas construes
executveis.
Controle
Construes executveis podem ser utilizadas para controlar quais blocos de um programa sero executados
e/ou quantas vezes um bloco ser executado.
Um bloco sempre (obrigatoriamente) est envolvido pelas instrues que definem a construo executvel onde
est inserido. Nos exemplos que segue os blocos esto destacados com fundo cinza.
IF(a>0) THEN

b=sqrt(a) !estas duas declaraes
c=log(a) !formam um bloco

END IF
SELECT CASE (n)
case (1:)

print*,"n >= 1"

case default

print*,"n < 1"

END SELECT CASE
DO

print*,"esta construo"
print*,"DO infinita"

END DO
7.1. Construo DO com contagem
A construo DO com contagem um processo iterativo (loop) em que as iteraes so executadas um
nmero finito de vezes. A sua forma geral :
DO var = m1, m2, m3

bloco

END DO
O fluxograma mostra uma construo DO com contagem
Observe que, no fluxograma, no h nenhuma indicao
sobre o contedo do bloco de instrues. Ele foi
simplesmente identificado pela expresso bloco.
DO var = m1, m2, m3

bloco_do_DO

END DO
onde:
var uma varivel inteira (obrigatoriamente inteira) chamada de varivel do DO
m1 o valor inicial, que pode ser obtido de uma expresso-escalar inteira
m2 o valor final, que pode ser obtido de uma expresso-escalar inteira
m3 o incremento, que pode ser obtido de uma expresso-escalar inteira
Se m3 (o incremento) no utilizado, seu valor feito igual a 1.
A varivel da construo DO (var) definida com o valor inicial igual a m1.
A contagem das iteraes e feita pela expresso:
( m
2
m
1
+m
3
)
m
3
ATENO: m3 no pode igual a zero.
Se o valor desta expresso for negativo o contador de iterao zerado.
O contador feito igual a zero quando:
m
1
>m
2
e m
3
>0 ou
m
1
m
2
e m
3
0
Exemplos de iterao com contagem:
program loop_1
!-----------------------------------------
!Exemplo de construo DO com contagem
!-----------------------------------------
implicit none
integer:: i ! varivel do DO
do i = 1, 7, 2
print"(a,i1)","i = ", i
end do
end program loop_1
Nmero de iteraes:
( m
2
m
1
+m
3
)
m
3
=
(71+2)
2
=
8
2
=4
Sada: i = 1
i = 3
i = 5
i = 7
program loop_2
!-----------------------------------------
!-----------------------------------------
implicit none
do i = -20, 10, 5
print"(a,i3)","i = ", i
end do
end program loop_2
Nmero de iteraes:
(10(20)+5)
5
=
35
5
=7
Sada: i = -20
i = -15
i = -10
i = - 5
i = 0
i = 5
i = 10
program loop_3
!-----------------------------------------
!-----------------------------------------
implicit none
do i = 10, 0, -1
print"(a,i2)","i = ", i
end do
end program loop_3
Nmero de iteraes:
(010+(1))
1
=
11
1
=11
Sada: i = 10
i = 9
i = 8
i = 7
i = 6
i = 5
i = 4
i = 3
i = 2
i = 1
i = 0
7.2. Construo DO infinito
A construo DO sem contagem (tambm chamada de DO infinito DO forever) escrita assim:
DO
. . . .
. . . .
END DO
Um exemplo simples (e intil) :
program trava_o_micro
!-----------------------------------------------------------------------------
!-- Programa exemplo de uso da construo DO infinita.
!-- Este programa intil, pois trava o micro ou o terminal (janela window)
!-- onde est sendo executado. Para destravar o terminal pressione CTR-C
!-----------------------------------------------------------------------------
!-- AUTOR: Anibal L. Pereira 09/04/2010
!-----------------------------------------------------------------------------
implicit none
do
print*,"Repetindo este texto sem parar "
end do
end program trava_o_micro
O fluxograma ao lado mostra uma construo DO sem contagem (infinita), onde se
destaca o bloco de instrues da construo.
Observe que, neste fluxograma, no h nenhuma indicao sobre o contedo do
bloco de instrues. Ele foi identificado pela expresso bloco.
O fluxograma representa bem o programa trava_o_micro, que por no conter
nenhuma instruo que permita parar o processo iterativo (loop) ir travar o micro
(ou a janela em que estiver rodando)
7.3. Instruo Exit
Transformar uma construo DO infinita numa construo DO com critrio de parada essencial e s pode
ser feita pela utilizao da instruo de parada ( EXIT => em pseudocdigo: abandona ).
Uma construo DO infinita com critrio de parada passa a ser uma construo til.
A instruo EXIT a instruo utilizada para transformar um loop infinito num loop til.
A instruo EXIT uma instruo de parada. Quando executada (exit = sair) ela abandona (sai) a construo
executvel.
Exemplo de uma construo DO com critrio de parada:
DO
. . .
. . .
if( x > 10 ) exit
. . .
. . .
END DO
Quando a expresso ( x > 10 ) da instruo IF satisfeita, a instruo exit executada, o que faz com que a
construo DO pare de ser executada.
As possibilidades de se usar a instruo IF dentro da construo DO esto identificadas no quadro que segue.
No Incio No meio No fim
DO
if( x > 10 ) exit
. . .
. . .
. . .
. . .

END DO
DO
. . .
. . .
if( x > 10 ) exit
. . .
. . .

END DO
DO
. . .
. . .
. . .
. . .
if( x > 10 ) exit

END DO
Os fluxogramas correspondentes a estas construes so mostrados a seguir.
DO
if( x > 10 ) exit
. . .
. . .
. . .
. . .
END DO
DO
. . .
. . .
if( x > 10 ) exit
. . .
. . .
END DO
DO
. . .
. . .
. . .
. . .
if( x > 10 ) exit
END DO
7.4. Instruo Cycle
A instruo CYCLE outra declarao de modificao de execuo do loop. Neste caso CYCLE (em
pseudocdigo: pula) especifica que a iterao passa imediatamente para a prxima iterao (pulando as instrues
escritas depois dela, se existirem). Ela equivalente a ter alcanado o fim do bloco, passando ento prxima
iterao.
Exemplos:
program loop_3
!-----------------------------------------
!-----------------------------------------
implicit none
do i = 10, 0, -1
print"(a,i2)","i = ", i
end do
end program loop_3
Nmero de iteraes:
(010+(1))
1
=
11
1
=11
Sada: i = 10
i = 9
i = 8
i = 7
i = 6
i = 5
i = 4
i = 3
i = 2
i = 1
i = 0
program loop_3_com_pula
!---------------------------------------------
!Exemplo de construo DO com instruo cycle
!---------------------------------------------
implicit none
do i = 10, 0, -1
if(modulo(i,2) == 0) cycle !no escreve os pares
print"(a,i2)","i = ", i
end do
end program loop_3_com_pula
Nmero de iteraes:
(010+(1))
1
=
11
1
=11
Sada: i = 9
i = 7
i = 5
i = 3
i = 1
7.5. Construo DO While
A forma de uma construo DO WHILE :
DO WHILE(expr-lgica)
. . . .
boco-do-while
. . . .
END DO
onde:
expr-lgica uma expresso lgica que ser avaliada em verdadeira ou falsa
A construo DO WHILE (while = enquanto) especifica que o bloco-do-while ser repetido enquanto a condio
especificada permanecer verdadeira.
Exemplos:
k = 1
DO WHILE( k < 4)
k = k + 1
print*,"k = ", k
end do
Imprime:
k = 2
k = 3
k = 4
i = 0
x = -0.1
DO WHILE( sin(x) < cos(x) )
x = x + 0.1
i = i + 1
y = sin(x) + cos(x+0.03)
print*,"i = ", i, "y = ", y
end do
Imprime:
i = 1 y = 0.99955004
i = 2 y = 1.0913953
i = 3 y = 1.1723357
i = 4 y = 1.2415626
i = 5 y = 1.2983841
i = 6 y = 1.3422326
i = 7 y = 1.3726701
i = 8 y = 1.3893921
i = 9 y = 1.3922318
k = 20
DO WHILE( k < 4)
k = k + 1
print*,"k = ", k
end do
Esta construo DO WHILE no ser executada,
pois a condio k<4 com k = 20 sempre ser falsa
8. Construtor de Matriz
O Fortran disponibiliza uma forma bastante compacta que pode ser utilizada com matrizes, chamada de
construtor de matriz (arry constructor).
matriz unidimensional
O construtor de matriz uma forma bastante prtica para entrar dados numa matriz unidimensional.
O construtor de matriz formado pelos valores que se deseja atribuir cada elemento da matriz unidimensional
colocados entre o totem (token) abre colchetes ' [ ' e o totem (token) fecha colchetes ' ] '
FORTRAN 95:
no padro Fortran 95 temos que usar ' (/ ' e ' /) ' no lugar de '[' e ']'
ento, o construtor de matriz
massa=[ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 ]
no Fortran 95 ficaria assim
massa=(/ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20/)
o Fortran 2003 aceita qualquer uma destas formas no construtor de matriz,
entretanto d preferncia a usar a notao do Fortran 2003
Evite usar a notao do Fortran 95
Use os colchetes [ e ] em vez dos toten (/ e /)
O programa construtor_01 evidencia como se escreve valores inteiros iguais aos valores dos ndices dos
elementos em cada um dos elementos da matriz unidimensional massa:
program construtor_01
!-------------------------------------------
!Usando o construtor de matriz
!-------------------------------------------
implicit none
integer, dimension(1:20):: massa

!--- entrando com valores na matriz massa
massa=[ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20 ]
!--- mostrando a matriz na tela do micro
print*
print"(a,20i3)","matriz massa=>", massa
print*
print"(a,i4)","massa(3)*massa(10)=",massa(3)*massa(10)
print*
end program construtor_01
O seguimento de programa abaixo entra
com os mesmos valores na matriz:
massa(1)=1
massa(2)=2
massa(3)=3
massa(4)=4
massa(5)=5
massa(6)=6
massa(7)=7
massa(8)=8
massa(9)=9
massa(10)=10
massa(11)=11
massa(12)=12
massa(13)=13
massa(14)=14
massa(15)=15
massa(16)=16
massa(17)=17
massa(18)=18
massa(19)=19
massa(20)=20
Escreva o programa construtor_01 e execute para ver a sua sada.
possvel tambm atribuir valores iniciais a (ou como usualmente se diz: inicializar) uma matriz durante a sua
declarao. O programa construtor_02 define e inicializa a matriz massa que possu 3 posies fazendo uso de
um construtor de matriz.
!----------------------------------------------------
!Usando construtor de matriz e inicializando a matriz
!----------------------------------------------------
implicit none
integer,dimension(3):: massa=[10,33,21]

print*
print"(a,i4)","massa(1) + massa(2)=", massa(1) + massa(2)
print*
Escreva o programa construtor_02 e execute para ver a sua sada.
Claro que tambm possvel entrar os valores na matriz trabalhando-se com cada elemento individualmente,
como mostrado no programa construtor_03.
!---------------------------------------------
!Entra valores elemento a elemento na matriz
!---------------------------------------------
implicit none
integer,dimension(3):: massa

massa(1) = 10
massa(2) = 33
massa(3) = 21
print*
print"(a,i4)","massa(1) + massa(2)=", massa(1) + massa(2)
print*

9. Do implcito
O uso de um construtor de matriz para entrar valores numa matriz uma tcnica bastante simples, porm
implica em escrever cada um dos dados individualmente, assim como a tcnica de entrar individualmente os dados
em cada elemento. O uso de um Do implcito pode facilitar o processo de entrada dos dados.
O Do implcito uma sintaxe especial utilizada com matrizes que utiliza a instruo Do. Ele tem a seguinte
forma:
(lista, do_implcito)
onde: do_implcito tem a mesma estrutura da instruo Do com nmero de iteraes contadas e lista uma
lista de objetos (que possam ser escritos na matriz) separada por vrgula.
Exemplo:
............
integer,dimension(1:20):: massa
............
massa=[ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
............
pode ser escrita de uma forma compacta usando o do implcito:
............
integer:: i
............
massa=[ (i, i=1,20) ]
............
Por exemplo:
massa=[ -5,(0,i=1,26),15,20,90 /]
Escreva este programa e execute-o
program simples
integer:: i
massa=[ -5,(0,i=1,26),15,20,90 ]
do i=1,30
print"(a7,i2,a2,i2)", "massa(",i,")=", massa(i)
end do
end program simples
A declarao massa=[ -5,(0,i=1,26),15,20,90 ] gera a matriz massa contendo os seguintes valores:
massa(1) = -5
massa(2) = 0 !----
massa(3) = 0 !
.............. ! massa(2) at massa(27) todas zero
.............. !
massa(27) = 0 !----
massa(28) = 15
massa(29) = 20
massa(30) = 90 conforme voc pode constatar verificando a sada do programa simples
Caso no se utilizasse o DO implcito, o construtor de matriz teria que ser escrito assim:
massa=[ -5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,20,90 ]
veja como muito mais compacto escrever: massa=[ -5,(0,i=1,26),15,20,90 ]
10. Instruo RESHAPE
O construtor de matriz (array constructor) permite entrar com valores nos elementos da matriz, mas devido a
sua caracterstica de entrar valores de forma sequencial, quando no se trabalha com uma matriz unidimensional
necessrio especificar a forma da matriz para que os valores sejam colocados na matriz ( ou seja, nos elementos)
corretamente.
A caracterstica importante que no pode ser esquecida para o Fortran que os valores contidos num construtor
de matriz sero escritos sequencialmente e os dados sempre so enviados coluna da matriz no linha.
A forma geral da instruo rechape :
reshape( construtor-matriz, forma-matriz )
Ento a instruo a = reshape( [1,2,3,4,5,6,7,8,9],[3,3] )
a matriz a=
1 4 7
2 5 8
3 6 9

a=reshape( [1,2,3,4,5,6,7,8,9],[3,3] )
|___| | | | | |_|
| |___| | | |
| | |___| forma
1
a
coluna | |
2
a
coluna |
3
a
coluna
11. Matriz Inteira
Matriz inteira (whole-array) permite trabalhar com a matriz como um todo, isto , trata a matriz como um objeto
simples, tal como se trabalha com um objeto escalar.
Quando se atribui um valor a uma matriz inteira, isto significa que cada elemento da matriz conter este valor.
O programa matriz_inteira_2a mostra isto com clareza.
program matriz_inteira_2a
!-------------------------------------------
!Multiplicao com matriz inteira
!-------------------------------------------
implicit none
!
!--- entrando com valores na matriz A
A(1,1) = 1.1
A(1,2) = 1.2
A(2,1) = 2.1
A(2,2) = 2.2
A = 2 * A
print*
print*,"Matriz 2A "
print*
print"(2f6.1)",A(1,:)
print"(2f6.1)",A(2,:)
print*
end program matriz_inteira_2a
12. Seo de Matriz
Uma matriz um conjunto multidimensional de variveis de mesmo tipo.
............
real:: x
integer,dimension(5,5)::cubo
..................
x = cubo(3,4)/10.0
..................
A matriz cubo est definida como tendo 2 dimenses (rank = 2) e
contm 25 elementos [ 5x5=25 ; tamanho (size) = 25 ]
Uma matriz bidimensional pode ser entendida como sendo
equivalente a um arranjo de linhas e colunas.
cubo(n , m)=
1,1 1,2 1,3 1,4 1,5

2,1 2,2 2,3 2,4 2,5
3,1 3,2 3,3 3,4 3,5
4,1 4,2 4,3 4,4 4,5
5,1 5,2 5,3 5,4 5,5
Cada elemento da matriz sempre referenciado pela sua posio

(linha e coluna) dentro da matriz.
Assim o elemento (3, 2) significa terceira linha e segunda coluna.
Observe que, em nosso exemplo, a primeira linha contm 5
elementos (um elemento em cada coluna): cubo(1,1), cubo(1,2),
cubo(1,3), cubo(1,4) e cubo(1,5).
Se a matriz cubo contiver os seguintes valores
5 6 7 8 9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24
25 26 27 28 29
ento:
cubo(1,1) = 5 linha 1 coluna 1
cubo(1,3) = 7 ........................
cubo(1,4) = 8 ........................
portanto a instruo x = cubo(3, 4) / 10.0 = 1.8
escreve na varivel x o valor 1.8.
Uma forma muito conveniente de trabalhar com matrizes trabalhar com sees da matriz.
O exemplo mostra como se pode trabalhar com uma linha ou uma coluna (que so pedaos sees da matriz):
Admita que a matriz a contm os seguintes valores: a=
1 4 7
2 5 8
3 6 9
. Ento o seguimento de programa

mostrado a seguir
integer,dimension(3,3):: a
a=reshape([1,2,3,4,5,6,7,8,9],[3,3])
print*,"coluna 1 ====> ",a(:,1)
print*,"linha 2 ====> ",a(2,:)
mostra na tela do computador o seguinte:
coluna 1 ====> 1 2 3
linha 2 ====> 2 5 8
Quando se usa o totem (token) " : " (dois pontos) em uma certa dimenso, esta dimenso fica definida como
tendo uma extenso que vai do primeiro elemento at o ltimo, porque os limites foram omitidos.
Este comportamento pode ser alterado especificando-se os limites inferiores e superiores desejados (lower
limit:upper limit).
Ento a instruo
print*,"coluna 1====> ",a(:2,1)
imprimir somente 2 elementos da coluna 1
coluna 1 ====> 1 2
enquanto a instruo
print*,"coluna 1====> ",a(:3,1)
equivalente a instruo print*,"coluna 1====> ",a(:,1) porque neste caso em particular o
limite superior igual a 3.
13. Matriz Alocvel
Matriz de Forma Postergada
Matriz de Forma Postergada uma Matriz Alocvel.
Matrizes de forma postergada (deferred) so matrizes que tem seu tamanho determinada apenas durante a
execuo do programa. As matrizes alocveis (allocable array) permitem fazer isto.
Uma matriz alocvel
definida pelo uso do atributo allocatable na definio da matriz
o tamanho da matriz definido numa instruo separada
depois de utilizada e, no sendo mais necessria, pode-se (deve-se) liberar o espao ocupado pela matriz
utilizando-se uma instruo de desalocamento (deallocation statement)
A matriz alocvel declarada assim:
real, allocatable, dimension(:,:):: A
O rank (quantidade de dimenses) da matriz igual ao nmero de dois pontos ( : ) , portanto a declarao acima
uma matriz bidimensional (rank = 2).
Uma matriz alocvel chamada de matriz de Forma Postergada (deferred-shape) porque quando ela
declarada a extenso em cada dimenso no especificada. As extenses so declarada posteriormente.
Exemplo:
. . .
integer ::n
real, allocatable, dimension(:) :: a ! Matriz unidimensional forma postergada
real, allocatable, dimension(:, :) :: b ! Matriz bidimensional forma postergada
. . .
read*, n
allocate( a(n), b(3*n, 5) ) !aqui feita a alocao da 2 matrizes
. . .
deallocate(a, b) !libera-se o espao de memria que as matrizes usavam
. . . .
Esta Folha contm
17 Atividades
05 atividades exemplos
04 atividades exemplos com ajustes e/ou acrscimos
06 atividades para serem feitas
02 atividades para serem ajustadas e/ou acrescidas
Seu professor de laboratrio (e/ou teoria) poder alterar esta relao !
Atividade 01
Considere uma tabela contendo o peso de 12 candidatos a uma vaga numa empresa.
nmero Candidato
(primeiro nome)
Peso
(kg)
1 Anibal 74.4
2 Jos 70.1
3 Paulo 83.4
4 Raul 80.3
5 Lus 71.4
6 Maria 67.2
7 Pedro 78.1
8 Joaquim 76.2
9 Carla 63.5
10 Antnio 66.1
11 Estela 61.9
12 Carlos 80.2
Entregar em meio magntico:
1. programa: peso_medio_1
peso_medio_2
peso_medio_1.f03
peso_medio_2.f03
2. arquivos: pesos_e_media_candidatos.dados
Exemplo/Acrscimo/Ajuste:
O programa peso_medio_1 calcula o valor mdio dos pesos dos 12 candidatos existentes na tabela.
Observe que os candidatos sero identificados na matriz unidimensional pelo seu ndice no pelo nome.
Escreva o programa, compile e depois execute-o.
FAZER:
escreva o programa peso_medio_2
remova a parte do programa que faz a solicitao dos 3 pesos
remova a parte do programa que fornece diretamente os pesos dos outros 9 candidatos
modifique o programa para que ele leia os pesos dos candidatos do arquivo pesos_e_media_candidatos.dados
depois, salve o resultado calculado (o valor mdio do peso) neste mesmo arquivo
certifique-se de escrever no arquivo um texto explicativo, indicando que o valor calculado o valor mdio, alm
claro do valor mdio calculado
Leia, nesta folha, o item 14 Especificador de conexo iostat
O especificador iostat permite que se faa um teste para certificar-se que a operao de abertura (conexo) do arquivo
foi bem sucedida ou no e s prosseguir com a execuo do programa se o sucesso da operao de conexo do
arquivo foi bem sucedida.
Se houver falha, na abertura do arquivo, o programa escrever uma mensagem informando ao usurio a ocorrncia desta
falha e imediatamente interrompo (para) a execuo do programa.
Parte do programa peso_medio2.f03 est disponibilizado na sequncia. Ele est incompleto, portanto voc deve completar o
programa para que ele funcione como solicitado.
teste
para ver o funcionamento do especificador iostat no programa, voc pode compilar e executar o programa
incompleto fornecido sem ter criado o arquivo de dados. Assim voc poder ver o valor fornecido pelo sistema
quando ele no encontra o arquivo de dados para conectar
________________________________________________________________________________________
arquivo: peso_medio_1.f03
program peso_medio_1
!
!------------------------------------------------------------------------------
! Propsito: Calcula a mdia dos valores contidos na matriz peso
!------------------------------------------------------------------------------
! Arquivo: peso_medio_1.f03
! Autor: Anibal L. Pereira 13/06/2010
!Revises:
!------------------------------------------------------------------------------
implicit none
real:: p_medio=0.0, & ! mdia dos pesos
soma_pesos=0.0 ! soma dos pesos
integer:: i, j, & ! contadores
N=12 ! nmero total de candidatos
real, dimension(1:12)::peso ! matriz de 12 elementos contendo os pesos em kg
!-----------------------------------------------------------------------
!--- para facilitar o uso do programa, parte dos dados ser solicitado
!--- pelo teclado e parte fornecido diretamente pelo programa
!
!--- Entrando apenas os 3 primeiros valores na matriz peso pelo teclado
!-----------------------------------------------------------------------
print*
print*,"Entrando os 3 primeiros pesos"
do i=1,3
print*
print"(a,i2.2,a)","Entre com o peso nmero ",i," em kg"
read*,peso(i)
end do
!-------------------------------------------------------
!--- definindo os 9 outros pesos da matriz
!-------------------------------------------------------
peso(4)= 80.3
peso(5)= 71.4
peso(6)= 67.2
peso(7)= 78.1
peso(8)= 76.2
peso(9)= 63.5
peso(10)= 66.1
peso(11)= 61.9
peso(12)= 80.2
!-------------------------------------------------------
!--- clculo do peso mdio
!-------------------------------------------------------
do j=1,12
soma_pesos = soma_pesos + peso(j)
end do
p_medio = soma_pesos / N
!-------------------------------------------------------
!--- Mostrando o resultado obtido
!-------------------------------------------------------
print*
print*,"O peso mdio dos 12 candidatos ", p_medio
!--- sada formatada
print*
print"(a,f4.1)","O peso mdio dos 12 candidatos ", p_medio
print*
end program peso_medio_1
As seguintes caractersticas devem ser vistas:
o programa define duas variveis numricas do tipo real
As variveis p_medio e soma_pesos foram definidas como sendo do tipo real e ao mesmo tempo, cada
uma delas, foi inicializada com o valor zero
Inicializar uma varivel significa definir e, ao mesmo tempo, atribuir um valor varivel
Observe tambm que estas variveis so escalares, isto , o nome que identifica a varivel refere-se
somente a um valor, s um valor, no vrios como no caso da matriz unidimensional
a seguir o programa define trs variveis numricas do tipo inteiro
N=12 ! nmero total de candidatos
as variveis i,j e N. Observe que somente a varivel inteira N foi inicializada
matriz
a instruo de declarao da matriz unidimensional
real, dimension(1:12):: peso ! matriz de 12 elementos contendo os pesos em kg
que o compilador enxerga assim:
real, dimension(1:12):: peso
uma instruo que define a matriz chamada peso que contm 12 elementos (de 1 at 12)
construo DO
o programa disponibiliza algumas informaes (como comentrios) e depois implementa a entrada de
dados pelo teclado
print*
print*,"Entrando os 3 primeiros pesos"
do i=1,3
print*
print"(a,i2.2,a)","Entre com o peso nmero ",i," em kg"
read*,peso(i)
end do
nesta parte do programa utilizado a construo DO.
A construo DO repete o bloco de instrues (instrues colocadas entre o do i=1,3 e o end do).
Neste exemplo a construo repete 3 vezes o bloco de instrues.
Observe como foi feito a paragrafao do bloco da construo DO, para facilitara leitura e visualizao
Atribuio de valores aos outros elementos da matriz unidimensional
Os outros 9 valores da matriz peso (componentes 4 a 12 ) foram definidos nas instrues
peso(4)= 80.3
peso(5)= 71.4
peso(6)= 67.2
peso(7)= 78.1
peso(8)= 76.2
peso(9)= 63.5
peso(10)= 66.1
peso(11)= 61.9
peso(12)= 80.2
o programa realiza os clculos para obter a mdia
usando uma construo DO
do j=1,12
end do
que neste caso repete 12 vezes a instruo: soma_pesos = soma_pesos + peso(j)
e, por fim, produz a sada do resultado na tela do computador
!-------------------------------------------------------
!-------------------------------------------------------
print*
!--- sada formatada
print*
print*
________________________________________________________________________________________
arquivo: peso_medio_2.f03
program peso_medio_2
!
!------------------------------------------------------------------------------
! Propsito: Calcula a mdia dos valores contidos na matriz peso
! L os valores de um arquivo
!------------------------------------------------------------------------------
! Arquivo: peso_medio_2.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
N=12, & ! nmero total de candidatos
var_io ! varivel para receber o valor do estado de abertura do arquivo
real, dimension(1:12)::peso ! matriz de 12 elementos contendo os pesos em kg
!-----------------------------------------------------------------------
! Conecta o arquivo de dados
!-----------------------------------------------------------------------
open(unit=40, file="peso_e_media_candidatos.dados", status="old", action="readwrite", &
iostat=var_io)
!-----------------------------------------------------------------------
! verifica se o arquivo foi aberto com sucesso ou no
!-----------------------------------------------------------------------
if(var_io == 0) then
!-- nenhum erro aconteceu ao conectar o arquivo de dados
!-- portanto, no faz nada
else
!-- algum erro aconteceu
print*
print*,"Um erro aconteceu ao conectar o arquivo de dados"
print*,"verifique seu arquivo de dados"
print*
print"(a,i3)","O valor obtido do sistema para o erro :=> ", var_io
print*
stop
end if
!-----------------------------------------------------------------------
! l os dados do arquivo e coloca os valores na matriz
!-----------------------------------------------------------------------
do i=1,12
read(unit=40, fmt=*) peso(i)
end do
!-------------------------------------------------------
!--- clculo do peso mdio
!-------------------------------------------------------
do j=1,12
end do
!-------------------------------------------------------
!-------------------------------------------------------
print*
!--- sada formatada
print*
print*
!-----------------------------------------------------------------------
! escreve no arquivo
!-----------------------------------------------------------------------
!-----------------------------------------------------------------------
! aps terminar o uso do arquivo, fecha o arquivo
!-----------------------------------------------------------------------
close(unit=40)
14. Especificador de conexo iostat
A instruo OPEN conecta (abre) um arquivo e associa-o unidade especificada. Por exemplo:
open(unit=20, file="pontos.dados", status="new", action="write")
cria um arquivo de dado chamado pontos.dados (se ele no existir) que ser referenciado pela unidade 20.
Porque a ao de escrita, pode-se escrever no arquivo.
At a tudo correto. E se o processo de conexo do arquivo falhar? Como podemos ficar sabendo que o processo
no foi bem sucedido? O Fortran disponibiliza o especificador de conexo iostat.
O especificador de conexo iostat tem as seguintes caractersticas:
IOSTAT=<int-var>
int-var uma varivel inteira que igual zero se o comando executou corretamente e um valor
positivo caso contrrio
valor igual a zero nenhum erro ocorreu
valor positivo erro (o valor indicar que tipo de erro ocorreu)
valor negativo fim de arquivo encontrado no ocorreu erro ou
fim de registro encontrado no ocorreu erro
Os valores tanto positivos quanto negativos so definidos pelo fabricante do compilador (particulares
do compilador), isto , cada fabricante tem a liberdade de utilizar o valor que desejar para indicar
condies diferentes, mas obrigatoriamente os valores sero como indicados: positivos ou
negativos
Ento, um exemplo de utilizao do especificador de conexo iostat, :
program especificador_iostat
!
!-------------------------------------------------------------------------------------------
! Propsito: Programa exemplo de uso do especificador de conexo iostat na declarao open
!-------------------------------------------------------------------------------------------
! Arquivo: esp_iostat.f03
!Revises:
!-------------------------------------------------------------------------------------------
implicit none
integer:: N !varivel contendo o valor retornado para o especificador de conexo iostat
open(unit=60, file="esp_iostat.dados", status="new", action="write", iostat=N)
if(N == 0) then
!-- o arquivo foi aberto com sucesso
write(unit=60, fmt=*) "arquivo est conectado para escrita, por isto escrevo esta linha"
elseif(N > 0) then
!-- ocorreu erro na abertura do arquivo
print"(a,i3)","Erro de abertura do arquivo: ", N
stop !--esta declarao para a execuo do programa
end if
close(unit=60)
end program especificador_iostat
1. certifique-se que no existe o arquivo: esp_iostat.dados no diretrio atual
2. execute o programa especificador_iostat
3. abra o arquivo esp_iostat.dados e lei o seu contedo (pode fechar ou no o arquivo: no delete o
arquivo)
4. execute uma segunda vez o programa especificador_iosta
5. Veja a sua sada ! Depois disto, delete o arquivo esp_iostat.dados.
Execute de novo o programa. O que aconteceu? Sem deletar o arquivo, no programa troque o valor do
especificador de conexo status de NEW para REPLACE. Execute novamente o programa. Veja o
comportamento do programa !
Atividade 02
1. programa: matriz_03 matriz_03.f03
Fazer:
Escreva o programa Fortran matriz_03 de forma tal que ele:
defina a matriz A (2x2) de nmeros inteiros e a matriz B (3x3) que contm nmeros reais
admita que a matriz A contenha os valores A=
2 3
4 5
. Estes valores devem ser inseridos dentro da matriz

utilizando instrues dentro do programa (ou seja, o usurio no precisa entrar com os dados pelo teclado, nem o
programa l os valores de um arquivo de dados)
escreva na tela do computador o resultado da seguinte operao (realizada utilizando os elementos da matriz)
2534
entre com valores na matriz B de forma que ela fique com os valores B=
2.5 3.1 1.2

4.4 1.5 5.2
1.9 4.0 5.0
. Os valores da
matriz devem estar definidos no programa, o usurio no necessita entrar com os valores, nem o programa l os
valores de um arquivo de dados
usando os elementos da matriz B escreva na tela do computador a soma dos elementos da linha 1 com a soma dos
elementos da linha 3 da matriz
tambm usando os elementos da matriz B escreva na tela do computador o produto da multiplicao dos elementos
da diagonal principal da matriz (ou seja, o valor 18.75, obtido pela multiplicao de 2.5 por 1.5 por 5.0)
Escreva o programa matriz_03, salvando-o no arquivo matriz_03.f03.
Compile e execute o programa.
Atividade 03
1. programa: matriz_04 matriz_04.f03
Fazer:
Escreva o programa Fortran matriz_04 que:
defina a matriz A (4x4) de nmeros inteiros A=
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
. Os valores dos elementos da matriz devem

estar definidos dentro do programa (o usurio no precisa entrar com os dados pelo teclado ou ler os dados de um
arquivo)
Mostrar na tela do micro
a soma dos elementos das colunas 1 e 3 ( o resultado 62 )
o produto dos valores contidos nas colunas pares de todas as linhas mpares ( o resultado 6825 )
Escreva o programa matriz_04, salvando-o no arquivo matriz_04.f03.
Compile e execute o programa.
Atividade 04
1. programa: iteracao_01 iteracao_01.f03
2. arquivos: Iteracao_01.dados
O programa utiliza processo de iterao com contagem para entrar valores nas linhas de numa matriz
linha 1
soma 4 a cada elemento a partir do primeiro elemento da linha
linha 2
soma 5 a cada elemento a partir do primeiro elemento da linha
linha 3
soma 1 a cada elemento a partir do primeiro
linha 4
desconsidera o valor fornecido; faz todos os valores da linha igual a 1
linha 5
mantm o primeiro valor; depois entra com uma sequencia de nmeros iniciando em 0 e subtraindo 3 a cada novo
valor
linha 6
mantm o primeiro valor e subtrai 1 de cada elemento para os valores subsequentes
Por exemplo: se os primeiros valores da cada linha forem: 1 , 4 , 7, 1, 3 e 6 a matriz fica assim:
A=
1 5 9 13 17 21
4 9 14 19 24 29
7 8 9 10 11 12
1 1 1 1 1 1
3 0 3 6 9 12
6 5 4 3 2 1

Execute o programa e entre com o valor 5 para todos os 6 valores solicitados para ver a matriz gerada
Entre com nmeros inteiros menores que 1000
Entre com nmeros inteiros maior que 1000
Modifique o descritor de formato 6i3 para 6i4 para 6i5, para 6i6 para ver o comportamento da sada quando se entra
valores maiores que 10, maiores que 100, maiores que 1000, maiores que 10000, maiores que 100000
FAZER:
escreva os cdigos necessrios para que o programa salve a matriz no arquivo de dados: iteracao_01.dados
________________________________________________________________________________________
arquivo: iteracao_01.f03
program iteracao_01
!
!------------------------------------------------------------------------------
! Propsito: O programa utiliza processo de iterao com contagem para entrar
! valores nas linhas de numa matriz
!------------------------------------------------------------------------------
! Arquivo: iteracao_01.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
integer, dimension(6,6):: A !matriz de valores inteiro
integer:: i, j !contadores para os processos de iterao
!-----------------------------------------------------------------------
!--- Entrada de dados
!-----------------------------------------------------------------------
print*
print*,"Entre com os valores inteiros dos elemento:"
print*,"nesta ordem: A(1,1), A(2,1), A(3,1), A(4,1), A(5,1), A(6,1) "
read*, A(1,1), A(2,1), A(3,1), A(4,1), A(5,1), A(6,1)
!-----------------------------------------------------------------------
!--- Escrevendo os valores nas linhas da matriz
!-----------------------------------------------------------------------
j=1
do i=4, 21, 4 !----linha 1
j=j+1
A(1,j) = A(1,1) + i
end do
j=1
do i=5, 29, 5 !----linha 2
j=j+1
A(2,j) = A(2,1) + i
end do
do i=1, 5 !----linha 3
A(3,i+1) = A(3,1) + i
end do
do i=1, 6 !----linha 4
A(4,i) = 1
end do
j=1
do i=0, -12, -3 !----linha 5
j=j+1
A(5,j) = i
end do
j=1
do i=5, 1, -1 !----linha 6
j=j+1
A(6,j) = A(6,j-1) - 1
end do

!-----------------------------------------------------------------------
!--- Escrevendo as linhas da matriz na tela do micro
!-----------------------------------------------------------------------
print*
print*,"linha 1=", A(1,:)
print*
!--- sada formatada
print"(a,6i3)","linha 1=", A(1,:)
print"(a,6i3)","linha 2=", A(2,:)
print"(a,6i3)","linha 3=", A(3,:)
print"(a,6i3)","linha 4=", A(4,:)
print"(a,6i3)","linha 5=", A(5,:)
print"(a,6i3)","linha 6=", A(6,:)
print*
end program iteracao_01
Atividade 05
1. programa: iteracao_02 iteracao_02.f03
Exemplo:
O programa
cria uma matriz 5x5 do tipo real
solicita um nmero inteiro positivo
que ser usado como primeiro valor da coluna 1
coluna 1
cada elemento subsequente na coluna 1 ter um valor 60% maior que o valor do anterior
coluna 2
conter os valores obtidos da multiplicao da coluna 1 por ela mesmo
coluna 3
1/3 da coluna 1 adicionada a coluna 2, elemento a elemento
coluna 4
uma sequencia de nmeros impares gerados utilizando a expresso 2n+1
coluna5
o nmero fornecido pelo usurio em todos os elementos da coluna
Por exemplo se o valor fornecido for 7 a matriz fica assim:
Matriz A:
7.0000000 49.000000 51.333332 15.000000 7.0000000
11.200000 125.43999 129.17332 31.000000 7.0000000
17.920000 321.12640 327.09973 63.000000 7.0000000
28.672001 822.08362 831.64093 127.00000 7.0000000
45.875202 2104.5342 2119.8259 255.00000 7.0000000
________________________________________________________________________________________
arquivo: iteracao_02.f03
program iteracao_02
!
!------------------------------------------------------------------------------
! Propsito: O programa utiliza processo de iterao com contagem para entrar
! valores nas colunas de numa matriz
!------------------------------------------------------------------------------
! Arquivo: iteracao_02.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
real, dimension(5,5):: A !matriz de valores inteiro
integer:: numero, & ! nmero fornecido pelo usurio
i, j !contadores para os processos de iterao
!-----------------------------------------------------------------------
!--- Entrada de dados
!-----------------------------------------------------------------------
print*
print*,"Entre com um valor inteiro positivo"
read*, numero

!-----------------------------------------------------------------------
!--- Escrevendo os valores nas colunas da matriz
!-----------------------------------------------------------------------
A(1,1)=numero
do i=2, 5 !----coluna 1 ---- observe qual dos ndices da matriz est variando ==> (i,1)
A(i,1) = A(i-1,1) * 1.6
end do
do i=1, 5 !----coluna 2
A(i,2) = A(i,1)*A(i,1)
end do
do i=1, 5 !----coluna 3
A(i,3) = (1.0/3.0)*A(i,1)+A(i,2)
end do
A(1,4)= 2*numero+1
do i=2, 5 !----coluna 4
A(i,4) = 2*A(i-1,4)+1
end do
do i=1, 5 !----coluna 5
A(i,5) = numero
end do
!-----------------------------------------------------------------------
!--- Escrevendo a matriz na tela do micro
!-----------------------------------------------------------------------
print*
print*,"Matriz A:"
print*
print*, A(1,:)
print*, A(2,:)
print*, A(3,:)
print*, A(4,:)
print*, A(5,:)
!--- sada formatada
print*
print*,"Matriz A:"
print*
print"(5EN12.2)", A(1,:)
print"(5EN12.2)", A(2,:)
print"(5EN12.2)", A(3,:)
print"(5EN12.2)", A(4,:)
print"(5EN12.2)", A(5,:)
print*
end program iteracao_02
Atividade 06
1. programa: vetor_06 vetor_06.f03
Exemplo:
O programa Fortran vetor_06 solicita que o usurio entre com dois vetores fora e calcula a resultante das foras no plano
XY:
vetores foras

F
1
=F
1x

i +F
1y
j e
F
2
=F
2x
i +F
2y
j
fora resultante:
F
R
=( F
1x
+F
2x
)
i +( F
1y
+F
2y
)
F
R
=F
Rx
2

i +F
Ry
2

j
,
F
R
=
.
F
Rx
2
+F
Ry
2
, tan 0=
F
Ry
F
Rx

calcule o vetor resultante, seu mdulo e ngulo com o eixo do X das seguinte operaes:

R=
A+
B
sendo
A=2
i +2

j
e
B=2
i 4

j
________________________________________________________________________________________
arquivo: vetor_06.f03
program vetor_06
!
!------------------------------------------------------------------------------
! Propsito: Calcula a resultante de duas foras no plano XY
!------------------------------------------------------------------------------
! Arquivo: vetor_06.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
real, dimension(2):: F1, & ! F1(1) = F1x e F1(2) = F1y
F2, & ! F2(1) = F2x e F2(2) = F2y
R ! R(1) = Rx e R(2) = Ry
real:: theta, & ! ngulo entre a resultante e o eixo X (radianos)
theta_g, & ! ngulo em graus
resultante ! mdulo da resultante
real, parameter:: rad_para_grau=180.0/3.141592 ! fator de converso de
! radiano para graus
!-----------------------------------------------------------------------
!--- Entra valores das Foras
!-----------------------------------------------------------------------
print*
print*,"Clculo da Fora resultante"
print*
print*,"Entre com os valores da fora F1 ==> F1x e F1y "
read*, F1(1), F1(2)
print*
print*,"Entre com os valores da fora F2 ==> F2x e F2y "
read*, F2(1), F2(2)
!-------------------------------------------------------
!--- clculo da resultante
!-------------------------------------------------------
R(1)= F1(1) + F2(1) ! Rx
R(2)= F1(2) + F2(2) ! Ry
resultante = sqrt(R(1)**2 + R(2)**2)
theta = atan(R(2)/R(1)) ! em radianos
theta_g = rad_para_grau * theta ! em graus
!-------------------------------------------------------
!-------------------------------------------------------
print*
print"(a,f7.1,a,f7.1,a)","O vetor resultante :", R(1), "i +", R(2), "j"
print*
print"(a,f8.1)","O mdulo da resultante vale :", resultante
print*
print"(a,f7.2,a,f7.2,a)","com ngulo theta de:", theta, " radianos ou", theta_g, " graus"
print*
end program vetor_06
Atividade 07
Ajustes/Acrscimos:
Modifique o programa Fortran vetor_06 de forma que:
o conjunto de instrues que solicita ao usurio a entrada das foras deve ser removido do programa
depois da remoo dos cdigos de entrada de dados pelo teclado, escreva os cdigos necessrios para que os
valores dos vetores foras sejam fornecidos utilizando um construtor de matriz
Escreva o programa vetor_07, salvando-o no arquivo vetor_07.f03.
Compile e execute-o.
Atividade 08
2. arquivos: vetor_08_entrada.dados
Ajustes/Acrscimos:
Modifique o programa Fortran vetor_07 de forma que:
o conjunto de instrues que entra dados utilizando um construtor de matriz seja removido do programa
agora escreva os cdigos necessrios para que os valores das foras sejam lidos de um arquivo
escreva o arquivo de dados coma os valores das foras
Escreva o programa vetor_08, salvando-o no arquivo vetor_08.f03.
Atividade 09
1. programa: medias_provas medias_provas.f03
2. arquivos: medias_provas_p1p2p3.dados
Fazer:
Escreva um programa Fortran que
defina 3 matrizes unidimensionais P1, P2, P3 que recebam as notas da prova 1, prova 2 e prova3 de uma turma
as notas obtidas pelos alunos foram:
aluno Notas da P1 Notas da P2 Notas daP3
1 8.4 7.2 6.3
2 7.0 2.2 4.5
3 3.9 4.4 6.4
4 5.8 6.7 6.0
5 5.5 5.0 6.3
6 8.3 8.7 10.0
7 7.3 7.0 7.9
8 4.6 5.1 6.7
9 2.4 1.5 2.2
10 10.0 9.2 9.6
11 7.1 6.1 8.7
12 6.4 4.6 7.3
13 9.4 7.1 6.5
14 3.4 3.0 2.2
15 5.4 6.5 7.3
entre com as notas das provas usando construtor de matriz
calcule as mdias de cada prova
mostre as mdias na tela do micro
Escreva o programa medias_provas, salvando-o no arquivo medias_provas.f03.
Atividade 10
1. programa: do_implicito_10 do_implicito_10.f03
2. arquivos: do_implicito_10.dados
O programa Fortran do_implicito_10 escreve os seguintes valores nas matrizes unidimensionais
matriz V1
V
1
=(1,3,5,4,6,8,10 ,5,3,1,1)
1, 3, 5 inicia em 1 e soma 2 ao anterior
4, 6, 8, 10 inicia em 4 e soma dois ao anterior
-5, -3, -1, 1 inicia em -5 e soma 2 ao anterior
matriz V2
V
2
=(5,2,5,4,5,6,5,8,5,10,5,12,5,14,5,16,5,18,5,20,5,22,5,24,5,26,5,28,5,30)
5, 2
5, 4
5, 6
. . . .
5, 8
. . . sequncia de pare de nmeros onde o primeiro nmero sempre o nmero 5 e segundo nmero inicia
com o valor 2 e os outros valores sempre igual ao numero anterior acrescido de 2
FAZER: escreva os cdigos necessrios para que os valores das matrizes sejam salvos no arquivo de dados
do_implicito_10.dados
________________________________________________________________________________________
arquivo: do_implicito_10.f03
program do_implicito_10
!
!------------------------------------------------------------------------------
! Propsito: gera matrizes unidimensionais utilizando DO implcito
!------------------------------------------------------------------------------
! Arquivo: do_implicito_10.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
real, dimension(11)::v1
integer, dimension(30)::v2
integer::i
!------------------------------------------------
! Gera o matriz V1
!------------------------------------------------
print*
v1=[1, 3, 5, 4, 6, 8, 10, -5, -3, -1, 1]
print"(a,11f6.1)","usando o construtor: V1=>", v1
!---a mesma matriz sendo gerado com uso do DO implcito
print*
v1=[ (i,i=1,5,2), (i,i=4,10,2), (i,i=-5,1 ,2) ]
print"(a,11f6.1)","usando o DO IMPLCITO: V1=>", v1
print*
print*
v2=[ (5,2*i,i=1,15) ]
print"(a,30i3)","DO IMPLCITO: V2=>", v2
print*
end program do_implicito_10
Atividade 11
1. programa: reshape_11 reshape_11.f03
2. arquivos: reshape_11.dados
O programa Fortran reshape_11 cria uma matriz 6x4 e escreve valores nela usando um construtor de matriz e a instruo
RESHAPE
reshape_11.dados
________________________________________________________________________________________
arquivo: reshape_11.f03
program reshape_11
!
!------------------------------------------------------------------------------
! Propsito: cria uma matriz utilizando DO implcito e a instruo RESHAPE
!------------------------------------------------------------------------------
! Arquivo: reshape_11.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
integer, dimension(6,4)::A, B
integer:: i, & ! contador
num ! nmero inicial para o DO implcito
!------------------------------------------------
! Entra com os valores na Matriz A
!------------------------------------------------
print*
print*,"Entre com um inteiro"
read*,num
A= reshape( [(i,i=num,num+24)],[6,4] )
!--- mostra os valores da matrizes
print*
print*,"Matriz A "
print*,A(1,:)
print*,A(2,:)
print*,A(3,:)
print*,A(4,:)
print*,A(5,:)
print*,A(6,:)
!------------------------------------------------
! Entra com os valores na Matriz B
!------------------------------------------------
B=reshape( [(i,i=10,20,2),((2*i)+1,i=0,15,3),(i,i=-25,-20),4,4,4,4,4,4],[6,4] )
!--- mostra os valores da matrizes
print*
print*,"Matriz B "
print*,B(1,:)
print*,B(2,:)
print*,B(3,:)
print*,B(4,:)
print*,B(5,:)
print*,B(6,:)
print*

end program reshape_11
Atividade 12
1. programa: reshape_12 reshape_12.f03
2. arquivos: reshape_12.dados
Fazer:
Escreva o programa Fortran reshape_12 que cria uma matriz 7x3 que:
utilize um construtor de matriz
utilize a instruo reshape para criar a matriz 7 x 3
primeira coluna
inicia com o valor 10 e os outros valores da coluna so obtidos pela valor anterior mais 3
segunda coluna
cada elemento na coluna a raiz cbica do elemento correspondente na coluna 1
terceira coluna
cada elemento na coluna o o resultado da diviso da coluna 2 pela coluna1
reshape_12.dados
Escreva o programa reshape_12, salvando-o no arquivo reshape_12.f03.
Atividade 13
1. programa: matriz_inteira_13 matriz_inteira_13.f03
Exemplo:
O programa Fortran matriz_inteira_13 que cria uma matriz e entra com o mesmo valor em todos os seus elementos
________________________________________________________________________________________
arquivo: matriz_inteira_13.f03
program matriz_inteira_13
!
!------------------------------------------------------------------------------
! Propsito: cria uma matriz e entra mesmo valor em todos os seus elementos
!------------------------------------------------------------------------------
! Arquivo: matriz_inteira_13.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
real,dimension(2,2):: peso
real::num
!------------------------------------------------
! Entra com um nmero
!------------------------------------------------
print*
print*,"Entre com um inteiro"
read*,num
!------------------------------
! Uso de matriz inteira
!------------------------------
peso = num
!------------------------------
!mostrando a matriz
!------------------------------
print*
print*,"matriz peso"
print"(2f8.1)",peso(1,:)
print"(2f8.1)",peso(2,:)
!----------------------------------------------------------------
!mostrando a matriz usando a matriz inteira num instruo print
!----------------------------------------------------------------
print*
print*,"Usando a matriz inteira na declarao print"
print"(4f8.1)",peso
print*
end program matriz_inteira_13
Atividade 14
1. programa: secao_14 secao_14.f03
Exemplo:
O programa Fortran secao_14 que cria uma matriz e entra com o mesmo valor em todos os seus elementos
________________________________________________________________________________________
arquivo: secao_14.f03
program secao_14
!
!------------------------------------------------------------------------------
! Propsito: cria uma matriz utilizando DO implcito
! escreve a matriz na tela do computador e tambm
! mostra uma seo da matriz
!------------------------------------------------------------------------------
! Arquivo: secao_14.f03
!Revises:
!------------------------------------------------------------------------------
implicit none
integer, dimension(6,4)::A
num ! nmero inicial para o DO implcito
!------------------------------------------------
! Entra com um inteiro
!------------------------------------------------
print*
print*,"Entre com um nmero inteiro"
read*,num
A= reshape( [(i*i,i=num,num+24)],[6,4] )
!--- mostra os valores da matriz
print*
print*,"Matriz A "
print*,A(1,:)
print*,A(2,:)
print*,A(3,:)
print*,A(4,:)
print*,A(5,:)
print*,A(6,:)
print*
!--- mostra uma seo da matriz
print*,"Seo da Matriz A "
print*,A(3,3:4)
print*,A(4,3:4)
print*
end program secao_14
Atividade 15
1. programa: secao_15 secao_15.f03
Fazer:
Escreva um programa Fortran secao_15 que, usando construtor de matriz, crie a matriz A:
usando seo de matriz escreva a tela do computador a matriz linha por linha
Matriz A
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49
Usando seo de matriz, escreva na tela do micro o seguinte:
Seo da Matriz A
3 4 5
10 11 12
17 18 19
24 25 26
31 32 33
38 39 40
45 46 47
Usando seo de matriz, escreva na tela do micro o seguinte:
Seo da Matriz A
9 10
16 17
23 24
30 31
Atividade 16
1. programa: alocavel_16 alocavel_16.f03
Exemplo:
O programa Fortran alocavel_16 cria 4 matrizes unidimensionais de tamanho definido pelo usurio durante a execuo do
programa e insere valores nele seguindo a seguinte regra
vetA
cada elemento recebe um valor igual a sua posio dentro da matriz
vetB
cada elemento recebe o quadrado do valor da sua posio
vetC
cada elemento recebe o cubo do valor da sua posio
vetD
cada elemento recebe o valor da sua posio elevada a quarta potncia
depois desaloca as matrizes
A=
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31 32 33 34 35
36 37 38 39 40 41 42
43 44 45 46 47 48 49

a seguir cria uma matriz matE que tem tamanho definido pelo usurio, insere valores coluna por coluna (iniciando com o
nmero 1) at o ltimo elemento, mostra a matriz na tela do computador, desaloca a matriz e termina o programa.
________________________________________________________________________________________
arquivo: alocavel_16.f03
program alocavel_16
!
!----------------------------------------------------------------------------------------
! Propsito: programa simples para mostrar como pode-se criar matrizes unidimensionais e
! matriz alocveis
!----------------------------------------------------------------------------------------
! Arquivo: alocavel_16.f03
!Revises: Anibal L. Pereira 24/03/2011
!----------------------------------------------------------------------------------------
implicit none
integer,allocatable,dimension(:):: vetA, & ! matriz alocvel unidimensional vetA
vetB, & ! matriz alocvel unidimensional vetB
vetC, & ! matriz alocvel unidimensional vetC
vetD ! matriz alocvel unidimensional vetD
integer,allocatable,dimension(:,:):: matE ! matriz alocvel bidimensional matE
nv1, & ! tamanho da primeira matriz unidimensional
nv2, & ! tamanho da segunda matriz unidimensional
nv3, & ! tamanho da terceira matriz unidimensional
nv4, & ! tamanho da quarta matriz unidimensional
mt1, & ! tamanho da primeira dimenso da matriz
mt2 ! tamanho da segunda dimenso da matriz
!---------------------------------------------------------------------
! 4 nmeros inteiros para os tamanhos das matrizes unidimensionais
!---------------------------------------------------------------------
print*
print*,"Entre com 4 inteiros menores que 10 para os tamanhos das matrizes unidimensionais"
read*, nv1, nv2, nv3, nv4
!--- aloca as matrizes unidimensionais(cria as matrizes para serem usados)
allocate( vetA(nv1), vetB(nv2), vetC(nv3), vetD(nv4) )
!--- entra valores e mostra na tela do micro
vetA= [ (i,i=1,nv1) ]
vetB= [ (i*i,i=1,nv2) ]
vetC= [ (i**3,i=1,nv3) ]
vetD= [ (i**4,i=1,nv4) ]
print*
print*,"vetA=>",vetA
print*,"vetB=>",vetB
print*,"vetC=>",vetC
print*,"vetD=>",vetD
!----------------------------------------------------------------------------
! Desaloca as matrizes unidimensionais (destri as matrizes)
!----------------------------------------------------------------------------
deallocate( vetA, vetB, vetC, vetD )
!----------------------------------------------------------------------------
!--- agora se voc for trabalhar com as matrizes unidimensionais novamente
!--- ocorrer um erro, pois estar usando um objeto que no mais existe.
!--- ao desalocar as matrizes elas deixaram de existir para o programa
!---
!--- para ver isto ocorrendo, descomente a linha abaixo, salve, compile
!--- o programa e execute-o para ver o comportamento do programa.
!----------------------------------------------------------------------------
!print*,"vetA=>",vetA
!------------------------------------------------
! 2 nmeros inteiros para os tamanhos da matriz
!------------------------------------------------
print*
print*,"Entre 2 nmeros inteiros menores que 10 para os tamanhos da matriz"
read*,mt1, mt2
!--- aloca a matriz
allocate( matE(mt1,mt2) )
!--- entra com valores na matriz
matE= reshape( [(i,i=1,mt1*mt2)],[mt1,mt2] )
!--- mostra a matriz na tela do computador
print*
print*,"Matriz matE"
do i=1,mt1
print*,matE(i,:)
end do
!------------------------------------------------
! Desaloca a matriz
!------------------------------------------------
deallocate( matE )
end program alocavel_16
Atividade 17
1. programa: alocavel_17 alocavel_17.f03
Fazer:
O programa Fortran alocavel_17 tem que:
solicitar ao usurio o nmero de alunos, N, que deve ser entre 7 e 12
criar uma matriz 4xN (exemplo se N=12 a matriz ser 4x12), para guardar em cada linha da matriz as 4 notas de
um aluno
escrever na coluna 1 a nota P1, coluna 2 a nota da P2 e a nota da P3 na coluna 3 e
na coluna 4 a mdia do aluno calculada usando a expresso media=0.2P1+0.3P2+0.5P3
Para as notas dos alunos (na quantidade especificada pelo usurio, at 12) utilize os valores das notas disponveis para
realizar a atividade 08 (medias_prova)
Escreva o programa alocavel_17 salvando-o no arquivo alocavel_17.f03.

Fiscomp FA-03 2011-1

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Fiscomp FA-03 2011-1

Caricato da

Copyright:

Formati disponibili

Instituto de Fsica Armando Dias Tavares

Departamento de Fsica Aplicada e Termodinmica

enquanto a matriz unidimensional B fica

, o elemento(1,1) da matriz A guarda o valor 3.1 e

1,1 1,2 1,3 1,4 1,5

Cada elemento da matriz sempre referenciado pela sua posio

. Ento o seguimento de programa

. Estes valores devem ser inseridos dentro da matriz

2.5 3.1 1.2

. Os valores dos elementos da matriz devem

DFAT/Folha Atividades/FiscompFA Matriz e iterao 35

Potrebbero piacerti anche