Universidade do Estado do Rio de Janeiro Instituto de Física Armando Dias Tavares
Departamento de Física Aplicada e Termodinâmica Laboratório de Física Computacional/IF
Roteiro para Aula 1 de laboratório
1) Mostrar estrutura básica de um código em Fortran.
algoritmo fim algoritmo program nome_da_codificacao end program
2) Apresentar o indicador de comentário. {} no algoritmo e ! no Fortran algoritmo {comentário} fim algoritmo program nome_da_codificacao ! comentario end program 3) Apresentar o cabeçalho.
Se usa cabeçalho no Fortran; no algoritmo, as informações do cabeçalho estão na documentação externa.
algoritmo {declarações de variáveis e constantes} {bloco de instruções} fim algoritmo program nome_da_codificacao !================================== ! autor: ! data: ! arquivo fonte: ! ! proposito: !================================== ! declarações de variáveis ! e constantes ! bloco de instruções end program
4) Apresentar a instrução implicit none.
O Fortran, na sua criação, usava um artifício que simplificava a declaração de variáveis inteiras; quando uma variável começava com i, j, k, l, m e n, elas eram interpretadas automaticamente como variáveis inteiras, dispensando a declaração das mesmas; para anular este dispositivo, é necessário incluir sempre este comando – implicit none – forçando que todas as variáveis e constantes sejam declaradas explicitamente no código-fonte.
algoritmo {declarações de variáveis e constantes} {bloco de instruções} fim algoritmo program <nome> !================================== ! autor: ! data: ! arquivo fonte: ! ! proposito: !================================== implic none ! declarações de variáveis ! e constantes ! bloco de instruções end program
5) Apresentar a declaração de variáveis e constantes.
No algoritmo, usamos três tipos de variáveis e constantes: numéricos, literais e lógicos. No Fortran, o tipo numérico é dividido em duas categorias: inteiro (integer) e real (real). O tipo literal permanece literal (character) e o lógico permanece lógico (logical). Para se declarar variáveis e constantes no algoritmo usa-se o comando declarar:
declarar nome_da_variável tipo (valor_de_inicialização)
declarar nome_da_constante tipo constante (valor_de_inicialização)
declarar var1, var2, var3,... tipo (var1←valor1, var2←valor2, var3←valor3,...)
declarar const1,const2,const3,... tipo constantes (const1←valor1,const2←valor2,const3←valor3,...)
Declarações de variáveis declarar var numérico {se inteiro} declarar var numérico {se real} declarar var lógico declarar var literal {se caracter} declarar var[núm] literal {se string} integer::var ! se inteiro real::var ! se real logical::var character::var ! se caracter character(len=núm)::var ! se string
Com inicializações das variáveis
declarar var numérico (valor) {inteiro} declarar var numérico (valor) {real} declarar var lógico (valor) declarar var literal ('carácter') declarar var[núm] literal (“string”) integer::var = valor real::var = valor logical::var = valor character::var = 'carácter' character(len=núm)::var = “string”
Declarações de constantes com suas inicializações: declarar const numérico constante (valor) {inteiro} declarar const numérico constante (valor) {real} declarar const lógico constante (valor) declarar const literal constante ('carácter') declarar const[] literal constante (“string”) integer,parameter::var = valor real,parameter::var = valor logical,parameter::var = valor character,parameter::var = 'carácter' character(len=*),parameter::var = “string”
6) Apresentar os comando de entrada e saída. Os comando de entrada e saída são: read e print.
ler <lista de variáveis> escrever <informação a ser impressa> read *, <lista de variaveis> print *, <informação a ser impressa>
O comando read só aceita identificadores de variáveis, pois a informação que estará sendo lida deverá ficar armazenada em algum lugar, ou seja, numa variável, que é o elemento de informação próprio para isso. Não faz sentido usar o comando de leitura com uma constante, pois as constantes já são declaradas com seus valores correspondentes. O comando read pode trabalhar com uma ou mais variáveis (lista de variáveis). Se este for o caso (mais de uma), cada variável deverá estar separada por uma vírgula.
O comando print é o comando de saída de informação. Pode-se imprimir na tela do computador: valores constantes numéricos, literais e lógicos, variáveis e constantes. Em uma única instrução de print, o programador pode combinar qualquer uma destas informações entre si.
declarar a, b, c numéricos {inteiros} ler a, b, c escrever “a=”,a,” b:”,b,” e c é ”,c integer:: a, b, c read *, a, b, c print *, “a=”,a,” b:”,b,” e c eh ”,c
Exemplo de um algoritmo com declaração de variáveis, constantes, entradas e saídas.
algoritmo declarar a numérico {inteiro} declarar b numérico constante (b 0,34) ← {real} ler a escrever “a=”,a,” b=”,b fim algoritmo program exEntradaSaida implicit none integer:: a real, parameter:: b = 0.34 read *, a print *, “a=”,a,” b=”,b end program
7) Apresentar expressões aritméticas, lógicas e relacionais. As expressões seguem sempre um formato básico que é: resultado ← operando1 operador operando2
Existem operações que podem aceitar somente um operando. Esta operações são chamadas de unárias em contraposição às operações que aceitam dois operandos, isto é, são binárias. No caso das operações unárias, o formato é:
resultado ← operador operando
a) Os operadores aritméticos sâo: soma (+), subtração (–), multiplicação (*), divisão (/) e potenciação (**).
Soma resultado ← operando1 + operando2 Subtração resultado ← operando1 – operando2 Multiplicação resultado ← operando1 * operando2 Divisão resultado ← operando1 / operando2 Potenciação resultado ← operando1 ** operando2 resultado = operando1 + operando2 resultado = operando1 – operando2 resultado = operando1 * operando2 resultado = operando1 / operando2 resultado = operando1 ** operando2 Observações importantes
Numa operação aritmética binária, basta que um dos dois operando seja real para que o resultado da operação seja um valor real. Uma operação aritmética só gera um resultado inteiro se os operandos forem inteiros. Isso vale para qualquer operador aritmético. Continuando no Fortran:
program exMultiplicacao implicit none integer:: a, b, x real:: d, y a = 2 b = 3 d = 3.0 x = a*b ! resultado eh 6, inteiro, porque tudo eh inteiro y = a*d ! resultado eh 6.0, real por causa da variavel d x = a*d ! resultado eh 6, inteiro, por causa da variavel x y = a*b ! resultado eh 6.0, real, por causa da variavel y end program
Quando um valor real é atribuído a uma variável inteira, o resultado desta operação é inteiro por causa do efeito de truncamento. A parte decimal do valor constante armazenado na variável real é CORTADA, TRUNCADA, NÃO É ARREDONDADA.
O Fortran é em inglês. Logo, o sistema de representação decimal é com ponto (.) e não vírgula (,).
Numa expressão matemática, utiliza-se parênteses, colchetes e chaves. No Fortran utiliza-se somente parênteses. E os parênteses alteram a ordem de precedência das operações aritméticas tal qual na matemática. O que estiver dentro de parênteses é operado primeiro.
b) Os operadores lógicos são: e (conjunção), ou (disjunção) e não (negação). Este operadores devem ser sublinhados no algoritmo. O resultado de uma operação lógica é um valor lógico, isto é, FALSO ou VERDADEIRO.
No Fortan, estes operadores são: .and. (e), .or. (ou) e .not. (não). Os valores constantes lógicos FALSO e VERDADEIRO são, no Fortran: .false. (falso) e .true. (verdadeiro).
Conjunção (e) resultado ← operando1 e operando2 Disjunção (ou) resultado ← operando1 ou operando2 Negação (não) resultado ← não operando resultado = operando1 .and. operando2 resultado = operando1 .or. operando2 resultado = .not. operando algoritmo {tabela_verdade_e} declarar a, b, c lógicos escrever “a | b | a e b” a FALSO← b FALSO← c a ← e b escrever a,“ | ”,b,” | ”,c a FALSO← b VERDADEIRO← c a ← e b escrever a,“ | ”,b,” | ”,c a VERDADEIRO← b FALSO← c a ← e b escrever a,“ | ”,b,” | ”,c a VERDADEIRO← b VERDADEIRO← c a ← e b escrever a,“ | ”,b,” | ”,c fim algoritmo program tabela_verdade_e implicit none logical::a, b, c print*, “a | b | a e b” a = .false. b = .false. c = a .and. b print*, a,“ | ”,b,” | ”,c a = .false. b = .true. c = a .and. b print*, a,“ | ”,b,” | ”,c a = .true. b = .false. c = a .and. b print*, a,“ | ”,b,” | ”,c a = .true. b = .true. c = a .and. b print*, a,“ | ”,b,” | ”,c end program
algoritmo {tabela_verdade_ou} declarar a, b, c lógicos escrever “a | b | a ou b” a FALSO← b FALSO← c a ← ou b escrever a,“ | ”,b,” | ”,c a FALSO← b VERDADEIRO← c a ← ou b escrever a,“ | ”,b,” | ”,c a VERDADEIRO← b FALSO← c a ← ou b escrever a,“ | ”,b,” | ”,c a VERDADEIRO← b VERDADEIRO← c a ← ou b escrever a,“ | ”,b,” | ”,c fim algoritmo program tabela_verdade_ou implicit none logical::a, b, c print*, “a | b | a ou b” a = .false. b = .false. c = a .or. b print*, a,“ | ”,b,” | ”,c a = .false. b = .true. c = a .or. b print*, a,“ | ”,b,” | ”,c a = .true. b = .false. c = a .or. b print*, a,“ | ”,b,” | ”,c a = .true. b = .true. c = a .or. b print*, a,“ | ”,b,” | ”,c end program algoritmo {tabela_verdade_não} declarar a, b lógicos escrever “a | não a” a FALSO← c ← não a escrever a,“ | ”,b a VERDADEIRO← b ← não a escrever a,“ | ”,b fim algoritmo program tabela_verdade_e implicit none logical::a, b, c print*, “a | não a” a = .false. b = .not. a print*, a,“ | ”,b a = .true. b = .not.a print*, a,“ | ”,b end program c) Os operadores relacionais: os operadores relacionais comparam valores de mesma natureza (tipo). São operadores binários. As relações entre valores podem ser de: equivalência (igualdade), desigualdade, maior, maior ou igual, menor e menor ou igual. Em algoritmo, para cada uma das relações, temos os operadores: igualdade (=), desigualdade (/= ou ≠), maior (>), maior ou igual (>= ou ≥), menor (<) e menor ou igual (<= ou ≤). Em Fortram, o símbolo '=' não pode ser usado para comparação, pois significa atribuição (como pode ser visto nos exemplos anteriores). Então, para se avaliar a equivalência entre dois operandos, usar-se-á '==' ou o operador .eq..
