FORTRAN Verão lncc 2015

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

FORTRAN Verão lncc 2015/exemplos de programas/case.f90
program uso_do_case
implicit none
integer :: numero=5
select case (numero)
case (2)
	print *,numero, "~> azul"
case (5)
	print *, numero, "~> verde"
case (7)
	print *, numero, "~> preto"
case default
	print *, numero, "~> branco"
end select
end program uso_do_case
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._case.f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���¥lïtŸ€T¯ˆJóP“lÇ�Ärì�Ÿt[[¥ÚÚZ�ÉS�ž
FORTRAN Verão lncc 2015/exemplos de programas/do(1).f90
!PROGRAMA DE VERAO
!JOAO VICTOR M. B. 21/01/2015
!COMPILAR:
!gfortran -o nome_executavel nomeArquivo.f90
!EXECUTAR:
!./a.out ou ./nome_executavel
program teste2
implicit none
integer :: n,x,final
x=0
do n=1,100
	x = x+n
end do
print *,x
x=0
do n=100,1,-1 ! de 100 a 1 decrementando
	x=x+n
end do
print *,x
x=0
final=100
do n=1,final
	x=x+n
end do
print*,x
x=0
do while ((x < 100).and.(x>-5))! .or.
	x=x+6
end do
print *,x
end program teste2
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._do(1).f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���%�‹’`W¿àâà”¢�Ë2'7#7�”°t[[¥ÚÚZ�Å;�X
FORTRAN Verão lncc 2015/exemplos de programas/do.f90
program uso_do_do
implicit none
integer :: n, x, final
x=0
do n=1, 100
	x=x+n
end do
print *, x
x = 0
do n =100, 1, -1 !vai de 100 ate 1 decrementando 1
	x=x+n
end do
print *, x
x = 0
final = 100
do n=1, final
	x=x+n
end do
print *, x
x=0
do while ( (x < 100) .or. (x < 101) )
	x = X +6
end do
print*, x
end program uso_do_do
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._do.f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���%·Ü §b§Ü|�Œ�/Ï|OËܼd/ƒt[[¥ÚÚZ�˳�ª
FORTRAN Verão lncc 2015/exemplos de programas/if.f90
program teste
implicit none
logical :: cor
cor = 5 > 4 !Se a condicao for verdadeira, cor recebe TRUE, caso contrario, recebe FALSE
if (cor) then
	print *, "5 e maior que 4 mesmo"
else
	print *, "a logica ta doida"
end if
if( 2 > 3) then
	print *, "azul"
else if ( 2 < 4) then
	print *, "vermelho"
end if
end program teste
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
! para compilar						!
!							!							
! gfortran -o Nome_do_Executavel Nome_do_programa.f90 !
!							!
!para executar						!
!							!
!./Nome_do_Executavel					!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._if.f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���¥¬’¢ÌÈT'�÷<ÓÂ4Ó<wÃÒÂü€r[[¥ÚÚZ�Ðb�ô
FORTRAN Verão lncc 2015/exemplos de programas/if1.f90
!PROGRAMA DE VERAO
!JOAO VICTOR M. B. 21/01/2015
!COMPILAR:
!gfortran -o nome_executavel nomeArquivo.f90
!EXECUTAR:
!./a.out ou ./nome_executavel
program teste
implicit none
logical :: cor
cor = 2<4
!if(2>3) then
!	print *,"azul"
!else if (2>4) then
!	print *,"verde"
!else if (2>6) then
!	print *,"amarelo"
!else
!	print *,"vermelho"
!end if
if(cor) then
	if(3!=4) then
		print *,"azul"
	end if
	print *, "zzz"
end if
end program teste
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._if1.f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���¥¤$£ÄDߨtËÜ
íp³�$¿,KcËr[[¥ÚÚZ�Ä­�1
FORTRAN Verão lncc 2015/exemplos de programas/Kelvin_para_celsius.f90
function kt (k) result (result_c)
implicit none
real :: k , result_c
result_c = k - 273
end function kt
program KTC
implicit none
real :: kelvin = 373
real :: kt
print*, kt(kelvin)
end program KTC
__MACOSX/FORTRAN Verão lncc 2015/exemplos de programas/._Kelvin_para_celsius.f90
��������Mac OS X �����	���2���½�������ï��������������������������������������ATTR�������ï���œ���S�������������������œ���S���com.dropbox.attributes���xœ«VJ)Ê/HʯˆOËÌIÍL‰ÏÉONÌQ²R¨VÊMLÎÈÌ�‰%–”��…R�K���%c?�OÓœàü�çÈ,GãDÇr£b£Ì@[[¥ÚÚZ�½p��
__MACOSX/FORTRAN Verão lncc 2015/._exemplos de programas
FORTRAN Verão lncc 2015/slides/aula01.slides.pdf
 
Fortran para Modelagem 
Computacional
 
Ementa:
 Introdução a programação;
 Histórico do Fortran; 
 Tipos de dados;
 Estruturas de controle;
 Subprogramas;
 Vetores e Matrizes;
 Recursos de Entrada e Saída;
 Representação da realidade através de 
modelos computacionais; e
 Exemplo de codificação de modelos.
 
Site:
http://prjcuda10.lncc.br/fortran/
Só acessível dentro do LNCC
 
ALGORITMO
Definição: Um algoritmo é uma sequência 
não ambígua de instruções que é executada 
até que determinada condição se verifique.
Um algoritmo não representa, necessariamente, um programa de computador, e 
sim os passos necessários para realizar uma tarefa. Sua implementação pode ser 
feita por um computador, por outro tipo de autômato ou mesmo por um ser 
humano.
 
O abajur está 
conectado 
a tomada?
O lampada está 
queimada?
Conectar abajur 
a tomada
 O abajur não acende
Trocar lampada
Comprar um novo abajur
Não
Sim
Sim
Não
 
Em um algoritmo, os passos podem pertencer a uma 
das três naturezas:
 1. um operação elementar
 2. uma operação de controle especificando uma 
seleção entre sequência de passos
 3. uma operação de controle especificando a 
repetição de uma sequência de passos 
 
Seleções
 1. com um ramo
 se condição
 então seqüência de passos
 2. com dois ramos
 se condição
 então seqüência de passos 1 
 senão seqüência de passos 2 
 
Repetições
 1. teste do início
 enquanto condição repetir:
 sequência de passos
 2. teste no fim
 repetir:
 sequência de passos 
 até condição
 3. repetir um número conhecido de vezes
 repetir especificação de vezes
 sequência de passos 
 
Um programa de computador é simplesmente um conjunto de instruções para dizer 
ao computador como executar uma determinada tarefa em particular. Tal como uma 
receita culinária: que diz ao cozinheiro/a como se deve fazer tal prato em particular. 
Descreve os ingredientes (data) e os passos a seguir (o processo) para converter tais 
ingredientes numa sopa, ou outra coisa qualquer que se esteja a cozinhar. Os 
programa seguem o mesmo tipo de conceito.
PROGRAMA DE COMPUTADOR
Definição:Software, logicial ou programa de 
computador é uma sequência de instruções 
a serem seguidas e/ou executadas, na 
manipulação, redirecionamento ou 
modificação de um dado/informação ou 
acontecimento.
Em outras palavras: um programa de computador é a implementação de um 
algoritmo numa forma que o computador seja capaz de executar.
 
O COMPUTADOR
Computadores são inúteis. Eles podem somente te dar 
respostas.
 Pablo Picasso
Denomina-se computador o conjunto de artifícios 
eletrônicos capazes de efetuar qualquer espécie de 
tratamento automático de informações e/ou 
processamento
de dados. 
 
 
 
 
No futuros os computadores provavelmente não pesaram 
mais que 1,5 toneladas.
 Popular Mechanics (1949)
 
Organização Básica de um Computador Seqüêncial.
 
 
LEGENDA: 
01- Monitor 
02- Placa-Mãe 
03- Processador 
04- Memória RAM 
05- Placas de Rede, Som, 
Vídeo, Fax... 
06- Fonte de Energia 
07- Leitor de CDs e/ou DVDs 
08- Disco Rígido (HD) 
09- Mouse
10- Teclado
 
 BIT(simplificação para dígito binário, “BInary digiT” em inglês) é a 
menor unidade de informação usada na Computação e na Teoria da 
Informação, embora muitas pesquisas estejam sendo feitas em 
computação quântica com qubits. Um bit tem um único valor, 0 ou 1, 
ou verdadeiro ou falso, ou neste contexto quaisquer dois valores 
mutuamente exclusivos.
Embora os computadores tenham instruções (ou comandos) que 
possam testar e manipular bits, geralmente são idealizados para 
armazenar instruções em múltiplos de bits, chamados bytes. No 
princípio, byte tinha tamanho variável mas atualmente tem oito bits. 
Bytes de oito bits também são chamados de octetos. Existem 
também termos para referir-se a múltiplos de bits usando padrões 
prefixados, como kilobit (kb), megabit (Mb) e gigabit (Gb).
Fisicamente, o valor de um bit é, de uma maneira geral, armazenado 
como uma carga elétrica acima ou abaixo de um nível padrão em um 
único capacitor dentro de um dispositivo de memória.
BIT e BYTE
 
Linguagem de Máquina
Todo computador possui um conjunto de instruções que seu processador é capaz de 
executar. Essas instruções são representadas por sequências de bits, normalmente limitadas 
pelo número de bits do registrador principal da CPU.
As instruções correspondem a seqüencias muito simples de operações, como transferir um 
dado em memória para a CPU ou somar dois valores. 
Um programa em código de máquina consiste de uma sequência de números que significam 
uma sequência de instruções a serem executadas. É normal a representação da linguagem 
de máquina por meio de números em sistema binário 
 
Linguagens de Alto Nível
São as linguagens de programação que possuem uma estrutura e palavras-chave que são 
mais próximas da linguagem humana, tornando os programas mais fáceis de serem lidos 
e escritos. Esta é a sua principal vantagem sobre as linguagens de nível mais baixo. Os 
programas escritos nessas linguagens são convertidos para a linguagem assembly 
através de um programa compilador ou de um interpretador.
 
Compilador
Um compilador é um programa que, a partir de um código escrito em uma linguagem, 
o código fonte (do inglês source code), cria um programa semanticamente equivalente 
porém escrito em outra linguagem, código objeto (do inglês object code).
Sistema Operacional
Um computador sempre precisa de no mínimo um programa em execução por todo o 
tempo para operar. Tipicamente este programa é o sistema operacional (ou sistema 
operativo). O sistema operacional determina quais programas vão executar, quando, e 
que recursos (como memória e E/S) ele poderá utilizar. O sistema operacional também 
fornece uma camada de abstração sobre o hardware, e dá acesso aos outros 
programas fornecendo serviços, como programas gerenciadores de dispositivos 
("drivers") que permitem aos programadores escreverem programas para diferentes 
máquinas sem a necessidade de conhecer especificidades de todos os dispositivos 
eletrônicos de cada uma delas.
 
 
A primeira linguagem de programação de alto nível amplamente usada foi Fortran, criada 
em 1954.
Fortran
O primeiro compilador de FORTRAN foi desenvolvido para o IBM 704 em 1954-57 por 
uma equipa da IBM chefiada por John W. Backus.
O nome tem como origens a expressão "Formula Translator" (ou "Translation"). As 
versões iniciais da linguagem eram conhecidas como FORTRAN, mas o uso de 
maiúsculas foi ignorada em versões recentes da linguagem começando a partir do 
Fortran 90. Os padrões oficiais da linguagem referem-se a ela actualmente como 
"Fortran”.
 Diversas versões da definição da linguagem:
 * FORTRAN 66
 * FORTRAN 77
 * Fortran 90
 * Fortran 95
 * Fortran 2003
 * Fortran 2008
 
program oi
implicit none
write(*,*) "Oi Mundo"
end program oi
 
program soma
implicit none
integer:: a, b, total
a=2
b=2
total=a+b
write(*,*) total
end program oi
		Slide 1
		Slide 2
		Slide 3
		Slide 4
		Slide 5
		Slide 6
		Slide 7
		Slide 8
		Slide 9
		Slide 10
		Slide 11
		Slide 12
		Slide 13
		Slide 14
		Slide 15
		Slide 16
		Slide 17
		Slide 18
		Slide 19
		Slide 20
		Slide 21
		Slide 22
		Slide 23
		Slide 24
		Slide 25
__MACOSX/FORTRAN Verão lncc 2015/slides/._aula01.slides.pdf
FORTRAN Verão lncc 2015/slides/aula02.slides.pdf
 
Fortran para Modelagem 
Computacional
 
program oi
implicit none
print *, "Oi Mundo"
end program oi
 
Ementa:
 Introdução a programação;
 Histórico do Fortran; 
 Tipos de dados;
 Estruturas de controle;
 Subprogramas;
 Vetores e Matrizes;
 Recursos de Entrada e Saída;
 Representação da realidade através de 
modelos computacionais; e
 Exemplo de codificação de modelos.
 
Tipos de dados no Fortran
●Porque os dados devem ter tipos?
●Tipos disponíveis no Fortran
Integer:
123
0
-234
12_1
12_4
12_8
 
Parâmetro Kind
 Kind é uma forma de escolher entre as diferentes variações de 
um tipo de dado numa arquitetura e/ou compilador.
134556_4
12_SHORT
1.24_8
ASCII_”Fortran”
Kind pode não ser portável 12_2 em um compilador pode ter um 
número de bytes diferente em outro no mesmo computador. Pode 
se usar as funções SELECT_INT_KIND ou SELECT_REAL_KIND 
para manter a portabilidade.
 
Real:
12.5
0.23455
25.
.0
-478.13344
12E3 
12E-3
134.12_8
134.12_DOUBLE
 
Complex:
forma a + b i
(12, 5)
(0.23455, 12)
(25., 12.0)
(12E3,12E-3)
(134.12_4,134.12_DOUBLE)
 
Interger, Real e Complex são tipos numéricos e tem os 
seguintes operadores:
Aritméticos:
+
2+2
-
2-2
/
2/2
*
2*2
2**2
 
Interger, Real e Complex são tipos numéricos e tem os 
seguintes operadores:
Relacionais:
< (.lt.)
2<2
> (.gt.)
2>2
<= (.le.)
2<=2
>= (.ge.)
2>=2
== (.eq.)
2==2
/= (.ne.)
2/=2
 
Logical:
.true.
.false.
 
Operadores para Logical:
.not.
.and. 
.or.
.eqv.
.neqv.
.not. Inverte o valor
x y x .and. y x .or. y x .eqv. y x .neqv. y
.true. .true. .true. .true. .true. .false.
.true. .false. .false. .true. .false. .true.
.false. .true. .false. .true. .false. .true.
.false. .false. .false. .false. .true. .false.
 
●Character:
'LNCC '
“Fortran”
“Fortan LCC”
“12345” 
ASCII_”Fortran”
Character tem um operador que concatena: 
//
“aaa”//”bbb”
 
Variáveis 
 Área de memória no computador cuja finalidade é armazenar os dados ou 
informações de um programa. 
As variáveis são declaradas por tipos de dados.
integer :: x, y
real :: a, b
real (kind=8) :: c, d
logical :: teste
character (len=20) :: nome
real :: z, y=1.5, z
integer , parameter :: j=100
 
program soma
implicit none
integer:: a, b, total
a=2
b=2
total=a+b
print *, total
end program oi
		Slide 1
		Slide 2
		Slide
3
		Slide 4
		Slide 5
		Slide 6
		Slide 7
		Slide 8
		Slide 9
		Slide 10
		Slide 11
		Slide 12
		Slide 13
__MACOSX/FORTRAN Verão lncc 2015/slides/._aula02.slides.pdf
FORTRAN Verão lncc 2015/slides/aula03.slides.pdf
 
Fortran para Modelagem 
Computacional
 
Ementa:
 Introdução a programação;
 Histórico do Fortran; 
 Tipos de dados;
 Estruturas de controle;
 Subprogramas;
 Vetores e Matrizes;
 Recursos de Entrada e Saída;
 Representação da realidade através de 
modelos computacionais; e
 Exemplo de codificação de modelos.
 
Estruturas de controle
➢IF
➢CASE
➢DO
 
 
 IF
if ( expressão logica ) then
 trecho de código
else if ( expressão logica ) then
 trecho de código
else if ( expressão logica ) then
 trecho de código
else 
 trecho de código
end if
 
 CASE
select case if ( expressão )
case (valor) 
 trecho de código
case (valor) 
 trecho de código
case (valor) 
 trecho de código
case (valor) 
 trecho de código
case default 
 trecho de código
end select
 
program teste
implicit none
integer :: numero=5
select case ( numero )
case ( 2 )
 print *,numero, "azul"
case ( 5 )
 print *,numero, "verde"
case ( 7 )
 print *,numero, "amarelo"
case default 
 print *,numero, "vermelho"
end select
end program teste
 
DO
do controle do loop
 trecho de código
end do
 
program teste
implicit none
integer :: n, x , final
x=0
do n=1,100
 x=x+n
end do
print *, x
x=0
do n=100, 1,-1
 x=x+n
end do
print *, x
x=0
final=100
do n=1,final
 x=x+n
end do
print *, x
x=0
do while ( x < 100 )
 x=x+6
end do
print *, x
end program teste
 
program teste
implicit none
integer :: n, x , final
x=0
do 
 x=x+6
 if ( x > 500 ) exit
end do
print *, x
x=0
n=1
do while( n < 5000 )
 n=n+2
 if ( (n > 500) .and. (n < 3000) ) cycle
 x=x+n
end do
print *, x
x=0
n=1
do while( n < 5000 )
 n=n+2
! if ( (n > 500) .and. (n < 3000) ) cycle
 x=x+n
end do
print *, x
end program teste
 
Subprogramas
subroutine
subroutine exemplo(a, b)
 implicit none
 integer :: a, b
 a= a+b**2
end subroutine exemplo
program teste
 implicit none
 integer :: c,d
 c=2
 d=4
 call exemplo( c, d)
 print *, c
end program teste
 
Subprogramas
function
function foo(a, b) result(foo_result)
 implicit none
 integer :: a, b
 real :: foo_result
 foo_result=a+b**2 + 1.3256
end function foo
program teste
 implicit none
 integer :: c,d
 real :: foo
 c=2
 d=4
 print *, foo(c,d)
end program teste
		Slide 1
		Slide 2
		Slide 3
		Slide 4
		Slide 5
		Slide 6
		Slide 7
		Slide 8
		Slide 9
		Slide 10
		Slide 11
__MACOSX/FORTRAN Verão lncc 2015/slides/._aula03.slides.pdf
FORTRAN Verão lncc 2015/slides/aula04.slides.pdf
 
Fortran para Modelagem 
Computacional
 
#include <stdlib.h>
#include <stdio.h>
void to_fortran(int);
int main()
{
 int a=2;
 to_fortran(a);
 printf("a= %d\n", a);
}
subroutine to_fortran(i)
 implicit none
 integer, value :: i
 i=i+1
 print *,"i= ", i
end subroutine to_fortran
 
Ementa:
 Introdução a programação;
 Histórico do Fortran; 
 Tipos de dados;
 Estruturas de controle;
 Subprogramas;
 Vetores e Matrizes;
 Recursos de Entrada e Saída;
 Representação da realidade através de 
modelos computacionais; e
 Exemplo de codificação de modelos.
 
Vetor
Suponha que tenhamos os seguintes dados de temperatura:
23.1
17.3
34.2
22.4
21.1
26.2
Podemos guardá-los usando seis diferente variáveis:
temp1=23.1
temp2=17.3
temp3=34.2
temp4=22.4
temp5=21.1
temp6=26.2
 
Vetor
O Fortran tem uma foram melhor usando apenas uma 
variável. Esta variável terá um índice para guardarmos cada 
valor.
real, dimension(6) :: temp
temp(1)=23.1
temp(2)=17.3
temp(3)=34.2
temp(4)=22.4
temp(5)=21.1
temp(6)=26.2
 
Vetor
Por padrão o índice começa em 1, mas podemos dar um 
valor diferente
real, dimension(0:5) :: temp
temp(0)=23.1
temp(1)=17.3
temp(2)=34.2
temp(3)=22.4
temp(4)=21.1
temp(5)=26.2
real, dimension(-2:3) :: temp
temp(-2)=23.1
temp(-1)=17.3
temp(0)=34.2
temp(1)=22.4
temp(2)=21.1
temp(3)=26.2
 
Vetor
Podemos colocar todos os valores de uma vez:
real, dimension(1:6) :: temp
temp=(/ 23.1, 17.3, 34.2, 22.4, 21.1, 26.2 /)
Podemos usar um intervalo como indice:
print *, temp(3:5)
Multiplicar um vetor por um número:
temp=temp*3
Matrizes
real, dimension(6,10) :: temp
real, dimension(1:6,1:10) :: temp
real, dimension(6,10,10,5) :: temp
 
Recursos de entrada e saída
● OPEN
● READ
● WRITE
● PRINT
● CLOSE
● REWIND
● BACKSPACE
 
open(unit=11, file="teste.dat", status="new", & 
 access="stream", form="unformatted")
open(unit=12, file="teste.txt", status="old", &
 form="formatted")
open(unit=11, file="teste.dat", access="stream", & 
form="unformatted")
open(11, file="teste.dat", access="stream", form="unformatted")
 
Escrever em um arquivo binário (unformatted):
integer :: temp
open(unit=11, file="teste.dat", status="old", & 
 access="stream", form="unformatted")
temp=23
write(11) temp
close(11)
Para um vetor:
integer, dimension(100) :: temp
open(unit=11, file="teste.dat", status="old", & 
 access="stream", form="unformatted")
temp=23
write(11) temp
close(11)
 
Ler um arquivo binário (unformatted):
integer :: temp
open(unit=11, file="teste.dat", status="old", & 
 access="stream", form="unformatted")
read(11) temp
close(11)
Para um vetor:
integer, dimension(100) :: temp
open(unit=11, file="teste.dat", status="old", & 
 access="stream", form="unformatted")
read(11) temp
close(11)
 
Escrever em um arquivo texto (formatted):
integer :: temp
open(unit=11, file="teste.txt", status="old", & 
 form="formatted")
temp=23
write(11,*) temp
close(11)
Para um vetor:
integer, dimension(100) :: temp
open(unit=11, file="teste.dat", status="old", & 
form="unformatted")
temp=23
write(11,*) temp
close(11)
 
Ler um arquivo texto (formatted):
integer :: temp
open(unit=11, file="teste.txt", status="old", & 
 form="formatted")
read(11,*) temp
close(11)
Para um vetor:
integer, dimension(100) :: temp
open(unit=11, file="teste.dat", status="old", & 
form="unformatted")
read(11,*) temp
close(11)
		Slide 1
		Slide 2
		Slide 3
		Slide 4
		Slide 5
		Slide 6
		Slide 7
		Slide 8
		Slide 9
		Slide 10
		Slide 11
		Slide 12
		Slide 13
__MACOSX/FORTRAN Verão lncc 2015/slides/._aula04.slides.pdf
FORTRAN Verão lncc 2015/slides/aula05.slides.pdf
 
Fortran para Modelagem 
Computacional
Mariano Pereira Silva
mariano@mariano.pro.br
 
Ementa:
 Introdução a programação;
 Histórico do Fortran; 
 Tipos de dados;
 Estruturas de controle;
 Subprogramas;
 Vetores e Matrizes;
 Recursos de Entrada e Saída;
 Representação da realidade através de 
modelos computacionais; e
 Exemplo de codificação de modelos.
 
Models can perform two fundamentally different 
representational functions. On the one hand, a model can be a 
representation of a selected part of the world (the ‘target 
system’). Depending
on the nature of the target, such models are 
either models of phenomena or models of data. On the other 
hand, a model can represent a theory in the sense that it 
interprets the laws and axioms of that theory. (R.  Frigg  and  S. 
Hartmann, Models in Science. Entry in the Stanford Encyclopedia of Philosophy.)
 
Modelagem computacional
é uso de um computador para representar as respostas 
dinâmicas de um sistema pelo comportamento de outro 
sistema modelado nele. Uma simulação utiliza uma 
descrição matemática ou modelo de um sistema real, 
sob a forma de um programa de computador. Este 
modelo é composto por equações que duplicam as 
relações funcionais dentro do sistema real.
( Enciclopedia Britanica )
 
●Estocásticos
●Determinista 
●Mecanístico
●Estatísticos
●Estado estacionário 
●Dinâmico
 
 
Modelos são simplificações da realidade. Ou seja, 
parte dos fenômenos que ocorrem no mundo real são 
desprezados ou representado com equações 
imprecisas.
Além disso os dados utilizados pelos modelos tem 
sempre, em algum grau, um diferença da realidade. 
 
 “Essencialmente, todos 
os modelos estão errados, 
mas alguns são úteis”
George E. P. Box
 
ET
Tu
 é a evapotranspiração em mm
T é a temperatura em graus celcius 
R
s
 é a radiação solar em MJ m-2 day-1
 
Dados:
Numa matriz de 83 latitudes por 82 longitudes 
(6806 pontos), doze meses. Estão REAL de 32 
bits e “stream”. O valor -999,0 indica falta de 
dado.
 Radiação em W m-2 e a temperatura em Kº
Cº=Kº - 273,15
 
1 W m-2 = 0,0864 MJ m-2 day-1
 
Escolher o nome do programa:
-o nome_programa
gfortran -o modelo.exe model.f90 a2b.f90 tj.f90
Não gerar o executável, só o objeto:
-c
gfortran -c a2b.f90
Usar uma biblioteca:
-L/diretório/da/biblioteca
-lnome_da_biblioteca
gfortran -L/mlib/div/-lblas model.f90 a2b.f90 tj.f90
		Slide 1
		Slide 2
		Slide 3
		Slide 4
		Slide 5
		Slide 6
		Slide 7
		Slide 8
		Slide 9
		Slide 10
		Slide 11
__MACOSX/FORTRAN Verão lncc 2015/slides/._aula05.slides.pdf
FORTRAN Verão lncc 2015/slides/fortran90_refcard.pdf
Fortran 90 Reference Card
(c) 2008 Michael Goerz <goerz@physik.fu-berlin.de>
http://www.michaelgoerz.net
For a complete reference, I highly recommend
Adams, Brainerd, Martin, Smith, Wagener, Fortran 90 Handbook, Intertext Publications, 1992.
This work is licensed under the Creative Commons Attribution-Noncommercial-Share Alike 3.0 License. 
To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/
1 Data Types
1.1 Simple Data Types (entity-oriented declarations)
integer(specs) [,attrs] :: i=1 integer (with initialization)
real(specs) [,attrs] :: r real number
complex(specs) [,attrs] :: z complex number
logical(specs) [,attrs] :: b boolean variable
character(specs) [,attrs] :: s string
real, parameter :: c = 2.998 constant declaration
data i,j,k/3*0/ initialize i, j, k to 0
s2=s(2:5); s2=s(:5); s2=s(5:) substring extraction
attributes: parameter, pointer, target, allocatable, 
dimension, public, private, intent, optional, save, 
external, intrinsic 
specs: kind=..., for character: len=...
1.1 Derived Data Types
type person
 character(len=10) :: name
 integer :: age
end type person
Define person as derived data 
type
type(person) :: me instantiate person
me = person(“michael”, 24) constructor
name = me%name access structure component
1.2 Arrays and Matrices
real, dimension(5) :: v explicit array with index 1..5
real, dimension(-1:1,3) :: a 2D array, index -1..1, 1..3
integer :: a(-10:5), b(10,20) alternative array declaration
real, allocatable :: a(:) alloc. array ("deferred shape")
a=real(5,5); data a/25*0.0/ initialize 2D array
a=(/1.2,b(2:6,:),3.5/) array constructor
a=(/(I**2), I = 1, N)/) implied-do array constructor
v = 1/v + a(1:5,5) array expression
allocate(a(5),b(2:4),stat=e) array allocation
1.3 Pointers (avoid!)
real, pointer :: p declare pointer
real, pointer :: a(:) alloc. array ("deferred shape")
real, target :: r define target
p => r set pointer p to r
associated(p, [target]) pointer associated with target?
nullify(p) associate pointer with NUL
1.4 Operators
.lt. .le. .eq. .ne. .gt. .ge. relational operators
.not. .and. .or. .eqv. .neqv. logical operators
x**(-y) exponentiation
'AB'//'CD' string concatenation
2 Control Constructs
if (expr) action if statement
[name:] if (expr) then
 block
else if (expr) then [name]
 block
else [name]
 block
end if [name]
if-construct
select case (number)
 case (:0)
 block
 case (1:2)
 block
 case (3)
 block
 case (4:)
 block
 case default
 block
end select
select-statement
everything up to 0 (incl.)
number is 1 or 2
number is 3
everything up from 4 (incl.)
fall-through case
outer: do
 inner: do i=from,to,step
 if (...) cycle inner
 if (...) exit outer
 end do inner
end do outer
controlled do-loop
counter do-loop
next iteration
exit from named loop
do while (expr)
 block
end do
do-while loop
3 Program Structure
program foo
 use foo, lname => usename
 use foo2, only: [only-list]
 implicit none
 interface; ...
 end interface
 specification statements
 exec statements
 stop 'message'
contains
 internal-subprograms
end program foo
main program
used module, with rename
selective use
require variable declaration
explicit interfaces
variable/type declarations, etc.
statements
terminate program
subroutines, functions
module foo
 use foo
 public :: f1, f2, ...
 private
 interface; ... 
 end interface
 specification statements
contains
 internal-subprograms
end module foo
module
used module
list public subroutines
make private what's not public
explicit interfaces
variable/type declarations, etc.
“ module subprgs.”
subroutine foo(a,b,c,d,e,x,y)
 integer, intent(in) :: a
 integer, intent(inout) :: b
 integer, intent(out) :: c
 real, optional :: d
 character (len=*) :: e
 real, dimension (2:, :) :: x
 real, dimension (10, *) :: y
 if (present(d)) ...
 return
end subroutine foo
subroutine definition
read-only dummy variable
read-write dummy variable
write-only dummy variable
optional named argument
assumed length string
assumed-shape dummy array
assumed-size dummy array
presence check
forced exit
call foo(1,2,3,e="s",x=a,y=b) subroutine call
[real] function f(a,g)
 integer, intent(in) :: a
 [real :: f]
 interface
 real function g(x)
 real, intent(in) :: x
 end function g
 end interface
end function f
function definition
input parameter
return type, if not in definition
explicit interface block
define dummy var as function
recursive function f(x) ... allow recursion
incr(x) = x + 1 statement function
interface
 interface body
end interface
explicit interface of externals
ext. subroutine/function specs
interface generic-name
 interface body
 module procedure list
end interface
generic interface (overloading)
external subroutines/functions
internal subroutines/functions
interface operator op
 interface body
 module procedure list
end interface
operator interface
external functions
internal functions
interface assignment (=)
 interface body
 module procedure list
end interface
conversion interface
external subroutines
internal subroutines
4 Intrinsic Procedures
4.1 Transfer and Conversion Functions
abs(a) absolute value
aimag(z) imaginary part of complex z
aint(x, kind), anint(x, kind) to whole number real 
dble(a) to double precision
cmplx(x,y, kind) create x + iy (y optional)
int(a, kind), nint(a, kind) to
int (truncated/rounded)
real(x, kind) to real
conj(z) complex conjugate
char(i, kind), achar(i) char of ASCII code (pure 7bit)
ichar(c), iachar(c) ASCII code of character
logical(l, kind) change kind of logical l 
ibits(i, pos, len) extract sequence of bits
transfer(source, mold, size) reinterpret data
4.2 Arrays and Matrices
allocated(a) check if array is allocated
lbound(a, dim), ubound(a,dim) lowest/highest index in array
shape(a) shape (dimensions) of array
size(array, dim) extent of array along dim
all(mask, dim), any(mask, dim) check boolean array
count(mask, dim) number of true elements
maxval(a,d,m), minval(a,d,m) find max/min in masked array
product(a, dim, mask) product along masked dimen.
sum(array, dim, mask) sum along masked dimension
merge(tsource, fsource, mask) combine arrays as mask says
pack(array, mask, vector) packs masked array into vect.
unpack(vector, mask , field) unpack vect. into masked field
spread(source, dim, n) extend source array into dim.
reshape(src,shape,pad,order) make array of shape from src
cshift(a,s,d),eoshift(a,s,b,d) (circular) shift
transpose(matrix) transpose a matrix
maxloc(a,mask), minloc(a,mask) find pos. of max/min in array
4.3 Computation Functions
ceiling(a), floor(a) to next higher/lower int
conj(z) complex conjugate
dim(x,y) max(x-y, 0)
max(a1, a2, a3..), min(a1, ..) maximum/minimum
dprod(a,b) dp product of sp a, b
mod(a,p) a mod p
modulo(a,p) modulo with sign of a/p
sign(a,b) make sign of a = sign of b
matmul(m1, m2) matrix multiplication
dot_product(a,b) dot product of vectors
more: sin, cos, tan, acos, asin, atan, atan2, sinh, 
cosh, tanh, exp, log, log10, sqrt
4.4 Numeric Inquiry and Manipulation Functions
kind(x) kind-parameter of variable x
digits(x) significant digits in model
bit_size(i) number of bits for int in model
epsilon(x) small pos. number in model
huge(x) largest number in model
minexponent(x) smallest exponent in model
maxexponent(x) largest exponent in model
precision(x) decimal precision for reals in
radix(x) base of the model
range(x) dec. exponent range in model
tiny(x) smallest positive number
exponent(x) exponent part of x in model
fraction(x) fractional part of x in model
nearest(x) nearest machine number
rrspacing(x) reciprocal of relative spacing
scale(x,i) x b**i
set_exponent(x,i) x b**(i-e)
spacing(x) absolute spacing of model
4.5 String Functions
lge(s1,s2), lgt, lle, llt string comparison
adjustl(s), adjustr(s) left- or right-justify string
index(s, sub, from_back) find substr. in string (or 0)
trim(s) s without trailing blanks
len_trim(s) length of s, w/ trailing blanks
scan(s, setd, from_back) search for any char in set
verify(s, set, from_back) check for presence of set-chars 
len(string) length of string
repeat(string, n) concat n copies of string
4.6 Bit Functions (on integers)
btest(i,pos) test bit of integer value
iand(i,j), ieor(i,j), ior(i,j) and, xor, or of bit in 2 integers
ibclr(i,pos), ibset(i, pos) set bit of integer to 0 / 1
ishft(i, sh), ishftc(i, sh, s) shift bits in i
not(i) bit-reverse integer
4.7 Misc Intrinsic Subroutines
date_and_time(d, t, z, v) put current time in d,t,z,v
mvbits(f, fpos, len, t, tpos) copy bits between int vars
random_number(harvest) fill harvest randomly
random_seed(size, put, get) restart/query random generator
system_clock(c, cr, cm) get processor clock info
5 Input/Output
5.1 Format Statements
fmt = "(F10.3, A, ES14.7)" format string
Iw Iw.m integer form
Bw.m Ow.m Zw.m binary, octal, hex integer form
Fw.d decimal form real format
Ew.d exponential form (0.12..E-11)
Ew.dEe specified exponent length
ESw.d ESw.dEe scientific form (1.2...E-10)
ENw.d ENw.dEe engineer. form (123.4...E-12)
Gw.d generalized form
Gw.dEe generalized exponent form
Lw logical format (T, F)
A Aw characters format
nX horizontal positioning (skip)
Tc TLc TRc move (absolute, left, right)
r/ vert. positioning (skip lines)
r(...) grouping / repetition
: format scanning control
S SP SS sign control
BN BZ blank control (blanks as zeros)
w full length, m minimum digits, d decimal places, e exponent length, 
n positions to skip, c positions to move, r repetitions
5.2 Reading from and Writing to Files
call getarg(2, var) put 2nd CLI-argument in var
print '(i10)', 2 print to stdout with format
print *, “Hello World” list-directed I/O
write(unit, fmt, spec) list write list to unit
read(unit, fmt, spec) list read list from unit
open(unit, specifiers) open file
close(unit, specifiers) close file
inquire(unit, spec) inquiry by unit
inquire(file=filename, spec) inquiry by filename
inquire(iolength=iol) outlist inquiry by output item list
backspace(unit, spec) go back one record
endfile(unit, spec) write eof record
rewind(unit, spec) jump to beginning of file
5.3 I/O Specifiers (open)
iostat=integer-variable save iocode (error) to variable
err=label label to jump to on error
file='filename' name of file to open
status='old' 'new' 'replace'
 'scratch' 'unknown'
status of input file
access='sequential' 'direct' access method
form='formatted' 'unformatted' formatted/unformatted I/O
recl=integer length of record
blank='null' 'zero' ignore blanks/treat them as 0
position='asis''rewind'
 'append'
position, if sequential I/O
action='read' 'write'
 'readwrite'
read/write mode
delim='quote' 'apostrophe' 
 'none'
delimiter for char constants
pad='yes' 'no' pad with blanks
close-specifiers: iostat, err, status='keep' 'delete'
inquire-specifiers: access, action, blank, delim, direct, 
exist, form, formatted, iostat, name, named, nextrec, 
number, opened, pad, position, read, readwrite, recl, 
sequential, unformatted, write, iolength
backspace-, endfile-, rewind-specifiers: iostat, err
5.4 Data-Transfer Specifiers (read, write)
iostat=integer-variable save iocode (error) to variable
advance='yes' 'no' (non-)advancing data transfer
err=label label to jump to on error
end=label label to jump to on end of file
eor=label label for end of record
rec=integer record number to read or write
size=integer-variable number of characters read
__MACOSX/FORTRAN Verão lncc 2015/slides/._fortran90_refcard.pdf
FORTRAN Verão lncc 2015/slides/radiacao.dat
__MACOSX/FORTRAN Verão lncc 2015/slides/._radiacao.dat
FORTRAN Verão lncc 2015/slides/temperatura.dat
__MACOSX/FORTRAN Verão lncc 2015/slides/._temperatura.dat
__MACOSX/FORTRAN Verão lncc 2015/._slides
__MACOSX/._FORTRAN Verão lncc 2015