paradigmas_de_programacao_2_X.pdf

Paradigmas de Programação
Ronaldo F. Ramos
Instituto Federal do Ceará
6 de agosto de 2023

PARTE 2 - PARADIGMA IMPERATIVO
BASIC
BEGINNER ALL PURPOSE SYMBOLIC
INSTRUCTION CODE
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 2 / 121

Recursos
Linguagem de Uso Geral (Intrepretada e Compilada). Muito usada para
Jogos e Aplicações Científicas.
https://www.quitebasic.com/
https://www.freebasic.net/
https://www.justbasic.com/

A linguagem
1 Linhas numeradas
2 Comandos em letras maiúsculas (mudado posteriorteme)
3 Desvios condicionais e incondicionais (goto)
4 Subrotinas
5 Variáveis numéricas e alfanuméricas
6 Vetores e Matrizes

Comandos
Comandos básicos: ( CLS, DIM, DEF, END, FOR NEXT,GOTO, GOSUB
RETURN, IF THEN ELSE, INPUT, LET, LIST, OLD, PAUSE, PLOT,
PRINT, REM, SAVE STOP, WHILE WEND, )
Funções Embutidas: (ABS, ATN, COS, EXP, INT, LOG, RND, SIN, SQR,
TAN)

Exemplo 1
1 100 REM PLOT A NORMAL DISTRIBUTION CURVE
2 110
3 120 DEF FNN(X) = EXP(-(X^2/2))/SQR (2*3.14159265)
4 130
5 140 FOR X = -2 TO 2 STEP .1
6 150 LET Y = FNN(X)
7 160 LET Y = INT (100*Y)
8 170 FOR Z = 1 TO Y
9 180 PRINT " ";
10 190 NEXT Z
11 200 PRINT "*"
12 210 NEXT X
13 220 END

Exemplo 2
1 100 REM GUESSING GAME
2 110
3 120 PRINT "GUESS THE NUMBER BETWEEN 1 AND 100."
4 130
5 140 LET X = INT (100* RND (0) +1)
6 150 LET N = 0
7 160 PRINT "YOUR GUESS";
8 170 INPUT G
9 180 LET N = N+1
10 190 IF G = X THEN 300
11 200 IF G < X THEN 250
12 210 PRINT "TOO LARGE , GUESS AGAIN"
13 220 GOTO 160

Exemplo 2
1 230
2 250 PRINT "TOO SMALL , GUESS AGAIN"
3 260 GOTO 160
4 270
5 300 PRINT "YOU GUESSED IT , IN"; N; "TRIES"
6 310 PRINT "ANOTHER GAME (YES = 1, NO = 0)";
7 320 INPUT A
8 330 IF A = 1 THEN 140
9 340 PRINT "THANKS FOR PLAYING"
10 350 END

FORTRAN
FORMULA TRANSLATION

Principais Caracteríticas
1 Aplicações que precisam de cálculos complexos. Fórmulas difíceis de
programar em Assembly
2 Linguagem fácil de aprender para iniciantes
3 Compiladores Disponíveis em Todas as Arquiteturas
4 Muitos recursos e bibliotecas numéricas
5 Usada ainda hoje por cientistas que não querem perder tempo
aprendendo outra linguagem de programação

Linha do Tempo
1950 John W. Backus propôs aos seus superiores na IBM desenvolver
uma alternativa mais prática ao assembly para IBM 704
1954 Foi concluído Um rascunho de especificação para o sistema de
tradução de fórmula matemática da IBM.
1956 Primeiro manual da linguagem Fortran
1958 Surgiu o Fortran II e III com subrotinas e funções escritas pelo
usuário
1960 FORTRAN disponível para o IBM 709, 650, 1620, e 7090
1961 Surgiram as versões do Fortran IV
1966 Surgiu o Fortran 66 Padronizado pela ANSI
1978 Aprovado o Fortran 77
1991 Fortran 90 saiu atrasado trazendo mudanças no famoso F77
1997 Fortran 95
2003 Fortran 2003 - Fortran Moderno
2018 Fortran Atual
2023 Está prevista uma versão do Fortran 2023 para estes dias

Aplicação em Física
Simulação Hidro Magnético Relativística do Crescimento de Um Buraco
Negro
Feito em Fortran. (wikipedia)

Aplicações em Física
Feito em Fortran Animação em
https://en.wikipedia.org/wiki/File:Cylinder_flow.gif

GFortran
Instalar Localmente
sudo apt install gfortran
https:
//fortran-lang.org/en/learn/os_setup/install_gfortran/
Programar Online
https://play.fortran-lang.org/

Variáveis
Fortran é uma linguagem de tipagem forte (estática), o que significa que
cada variável deve ter um tipo (fixo). Existem 5 tipos de dados
incorporados em Fortran:
inteiro - para dados que representam números inteiros, positivos ou
negativos
real - para dados de ponto flutuante (não inteiros)
complexo - par composto por uma parte real e uma parte imaginária
caractere - para dados de texto
lógico - para dados que representam valores booleanos (verdadeiro ou
falso)

Queima - 001_hello_world
1 program hello
2 ! Isto é um comentário. Ignorado pelo computador.
Antigamente usava -se um C
3 print *, ’Queima **** do IFCE!’
4 end program hello
O * do print é a identificação da saída. No caso stdout.

Declarando Variáveis
A sintaxe para declarar variáveis é:
<tipo_variável> :: <nome_variável>
onde <tipo_variável> é um dos tipos de variáveis incorporados listados
acima e <nome_variável> é o nome que você deseja dar à sua variável.
Os nomes das variáveis devem começar com uma letra e podem ser
compostos por letras, números e underscores (sublinhados). No exemplo a
seguir, declaramos uma variável para cada um dos tipos de dados
incorporados.

Exemplo de Definição de Variáveis
Exemplo de declaração de variáveis em Fortran
1 program Variáveis
2 implicit none ! todas as variáveis devem ser
declaradas explicitamente
3 integer :: amount
4 real :: pi
5 complex :: frequency
6 character :: initial
7 logical :: isOkay
8 end program variables ..
ATENÇÃO: FORTRAN não é sensível ao caso. Antigamente usava-se
somente maiúsculas. Bom não misturar muito.

Exemplo de Definição de Variáveis
Exemplo de atribuições de valores a variáveis em Fortran
1 amount = 10
2 pi = 3.1415927
3 frequency = (1.0, -0.5)
4 initial = ’A’
5 isOkay = .false.

Saída Padrão
1 print *, ’0 valor de amount (integer) é: ’, amount
2 print *, ’0 valor de pi (real) é: ’, pi
3 print *, ’0 valor de frequency (complex) é: ’,
frequency
4 print *, ’0 valor de initial (character) é: ’,
initial
5 print *, ’0 valor de isOkay (logical) é: ’, isOkay

Entrada Padrão
read(unit, format) variable1, variable2, ...
Onde:
unit é um número inteiro que representa a unidade de entrada de onde os
dados serão lidos. * = stdin.
format é uma especificação opcional de formato.
1 program read_value
2 implicit none
3 integer :: idade
4 print *, ’Digite a sua idade: ’
5 read (*,*) idade
6 print *, ’Sua idade é: ’, idade
7 end program read_value

Operadores Aritméticos
Operator Descrição
** Exponenciação
* Multiplicação
/ Divisão
+ Adição
- Subtração

Aritmética - 002_aritmetica
1 program arithmetica
2 real :: pi
3 real :: raio
4 real :: altura
5 real :: area
6 real :: volume
7 pi = 3.1415927
8 print *, ’Entre com 0 raio do cilindro:’
9 read (*,*) raio
10 print *, ’Ent com altura do cilindro:’
11 read (*,*) altura
12 area = pi * raio **2
13 volume = area * altura
14 print *, ’raio é: ’, raio
15 print *, ’altura é: ’, altura
16 print *, ’area é: ’, area
17 print *, ’volume é: ’, volume
18 end program arithmetica

Precisão 003_precisao
A precisão desejada de ponto flutuante pode ser declarada explicitamente
usando um parâmetro ’kind’. O módulo intrínseco ’iso_fortran_env’
fornece parâmetros ’kind’ para os tipos de ponto flutuante comuns de 32
bits e 64 bits.
1 program float
2 use , intrinsic :: iso_fortran_env , only:
sp=>real32 , dp=>real64
3 implicit none
4
5 real(sp) :: float32
6 real(dp) :: float64
7
8 float32 = 1.0 _sp ! sufixo explícito para
constantes literais
9 float64 = 1.0 _dp
10
11 end program float

Explicação
use, intrinsic :: iso_fortran_env: instrui o compilador Fortran a usar o
módulo intrínseco iso_fortran_env. O módulo iso_fortran_env é fornecido
pelo Fortran standard (Fortran 2008) e fornece parâmetros que permitem
ao programador definir tipos de dados específicos com base no ambiente
do compilador e na arquitetura do sistema. Garante a portabilidade do
código entre diferentes plataformas.
only: sp=>real32, dp=>real64: Especifica que apenas os
identificadores sp e dp do módulo iso_fortran_env serão usados no código.
Além disso, ela está criando dois aliases (sp e dp) para os tipos de dados
de ponto flutuante de 32 bits e 64 bits, respectivamente.

Arrays e Strings
Arrays são variáveis multidimensionais que contêm mais de um valor, onde
cada valor é acessado através de um ou mais índices.
Em Fortran, os arrays são baseados em 1 por padrão; isso significa que o
primeiro elemento ao longo de qualquer dimensão está no índice 1.

Declarações de Vetores/Matrizes 004_arrays
Podemos declarar arrays de qualquer tipo. Existem duas notações comuns
para declarar variáveis de array: usando o atributo "dimension"ou
anexando as dimensões do array entre parênteses ao nome da variável.
1 program arrays
2 implicit none
3 ! 1D integer array
4 integer , dimension (10) :: array1
5 ! An equivalent array declaration
6 integer :: array2 (10)
7 ! 2D real array
8 real , dimension (10, 10) :: array3
9 ! Custom lower and upper index bounds
10 real :: array4 (0:9)
11 real :: array5 ( -5:5)
12 end program arrays

Slicing 005_array_slice
1 program array_slice
2 integer :: i
3 integer :: array1 (10) ! vetor 1D
4 integer :: array2 (10, 10) ! matriz 2D
5 array1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] !
Construtor
6 array1 = [(i, i = 1, 10)] ! Laço de construção
implícito
7 array1 (:) = 0 ! Vetor de zeros
8 array1 (1:5) = 1 ! 1 nos primeiros conco elementos
9 array1 (6:) = 1 ! todos elementos depois do 5 = 1
10 print *, array1 (1:10:2) ! Imprime posições ímpares
11 print *, array2 (:,1) ! Imprime o primeiro elemento
em uma 2D array
12 print *, array1 (10:1: -1) ! Imprime invertida
13 end program array_slice

Pausa para um Exercício
Faça um programa em Fortran para receber duas matrizes e responder
com a multiplicação delas da seguinte forma:
1 Multiplicação Elemento a Elemento (element wise)
2 Multiplicação Normal de Matrizes
3 Produto Interno (escalar)

Matrizes Dinâmicas Alocáveis 006_allocatable
Esses arrays são alocados enquanto o programa está em execução, assim
que soubermos o tamanho necessário do array.
1 program allocatable
2 implicit none
3
4 integer , allocatable :: array1 (:)
5 integer , allocatable :: array2 (:,:)
6
7 allocate(array1 (10))
8 allocate(array2 (10 ,10))
9
10 ! ...
11
12 deallocate(array1)
13 deallocate(array2)
14 end program allocatable

Strings 007_strings
Strings estáticas
1 program string
2 implicit none
3
4 character(len =4) :: first_name
5 character(len =5) :: last_name
6 character (10) :: full_name
7
8 first_name = ’John ’
9 last_name = ’Smith ’
10
11 ! String concatenation
12 full_name = first_name //’ ’// last_name
13
14 print *, full_name
15
16 end program string

Strings Alocáveis 008_alloc_strings
1 program allocatable_string
2 implicit none
3
4 character (:), allocatable :: first_name
5 character (:), allocatable :: last_name
6
7 ! Explicit allocation statement
8 allocate(character (4) :: first_name)
9 first_name = ’John ’
10
11 ! Allocation on assignment
12 last_name = ’Smith ’
13
14 print *, first_name //’ ’// last_name
15
16 end program allocatable_string

Matrizes de Strings 009_array_strings
1 program string_array
2 implicit none
3 character(len =10) , dimension (2) :: keys , vals
4 keys = [character(len =10) :: "user", "dbname"]
5 vals = [character(len =10) :: "ben", "motivation"]
6 call show(keys , vals)
7 contains ! região de subrotinas
8 subroutine show(akeys , avals)
9 character(len =*), intent(in) :: akeys (:), avals (:)
10 integer :: i
11 do i = 1, size(akeys)
12 print *, trim(akeys(i)), ": ", trim(avals(i))
13 end do
14 end subroutine show
15 end program string_array

Operadores Relacionais
Estão disponíveis os seguintes operadores relacionais:
Operador Alternativa Descrição
== .eq. Igualdade de dois operandos
/= .ne. Desigualdade de dois operandos
> .gt. Maior que
< .lt. Menor
>= .ge. Maior ou igual
<= .le. Menor ou igual

Operadores Lógicos
Estão disponíveis os seguintes operadores lógicos:
Operador Descrição
.and. e lógico
.or. ou lógico
.not. negação
.eqv. igualdade de valores lógicos
.neqv. desigualdade de valores lógicos

Pausa para Goto 010_goto
Não recomendado usar nos dias de hoje, mas foi indispensável antes do
conceito de programação estruturada.
1 program goto_
2 print *,’Vamos saltar um print ’ ! desvio
incondicional
3 goto vindo_para_ca
4 print *,’Este print não será executado ’
5
6 vindo_para_ca:
7 print *, ’Cheguei ao meu Destino ’
8 end program goto_

Quebra de Paradigma
A partir das experiências de programação primitivas com Fortran, Cobol,
PLI, Basic desenvolve-se a programação estruturada.

PARTE 2.1 - PARADIGMA IMPERATIVO
PROGRAMAÇÃO ESTRUTURADA
PROGRAMAÇÃO SEM GOTO

Algol
Criada para resolver os problemas de Legibilidade do Código em Fortran.
Serviu de base para várias outras (todas?) linguagens incluindo a
linguagem Pascal. Foi desenvolvida em consórcio Europa / USA.

Passagem de Parâmetros
Algol inovou nos conceitos de passagem de argumentos por nome,valor e
referência sendo também a primeira a usar os delimitadores begin e end
para iniciar e finalizar blocos de comandos.
1 begin
2 ...
3 ...
4 end

Similaridade com o Pascal
Algol é muito semelhante ao Pascal que era conhecida como uma
linguagem utilizada para ensinar programação estruturada. Segue um
exemplo de programa em Algol.
1 BEGIN
2 INTEGER i, sum;
3 sum := 0;
4
5 FOR i := 1 STEP 1 UNTIL 10 DO
6 sum := sum + i;
7
8 OUTSTRING("A soma dos números de 1 a 10 é: ");
9 OUTINT(sum);
10 ...
11 END.
Da mesma forma que o Fortran as letras maiúsculas não são mais
obrigatórias, porém maiúsculas e minúsculas são coisas distintas.

Origens e Influências das LPs

Continuando com o Fortran Estruturado

Evitando GOTOs com IFs estruturados
Aqui é importante mostrar a primeira grande mudança nas metodologias
de programação iniciando a era da programação estruturada.
1 if (angle < 90.0) then
2 print *, ’Angle is acute ’
3 else if (angle < 180.0) then
4 print *, ’Angle is obtuse ’
5 else
6 print *, ’Angle is reflex ’
7 end if

LOOP do 011_impares
Imprimindo uma lista de números ímpares usando o loop do.
1 program impares
2 integer :: i
3 do i = 1, 10, 2
4 print *, i ! Print odd numbers
5 end do
6 end program impares

Loops Condicionais WHILE 012_while
1 program while
2 integer :: i
3 i = 1
4 do while (i < 11)
5 print *, i
6 i = i + 1
7 end do
8 end program while

Interrompendo Loops EXIT 013_exit
1 program exit_
2 integer :: i
3 do i = 1, 100
4 if (i > 10) then
5 exit ! Stop printing numbers
6 end if
7 print *, i
8 end do
9 end program exit_

Interrompendo Loops Cycle 014_cycle
1 program cycle_
2 integer :: i
3 do i = 1, 10
4 if (mod(i, 2) == 0) then
5 cycle ! Don ’t print even numbers
6 end if
7 print *, i
8 end do
9 end program cycle_

Loops Aninhados com Tags de Controle 015_aninhados
1 program aninhado
2 integer :: i, j
3 outer_loop: do i = 1, 10
4 inner_loop: do j = 1, 10
5 if ((j + i) > 10) then ! Print only pairs of i
and j that add up to 10
6 cycle outer_loop ! Go to the next iteration
of the outer loop
7 end if
8 print *, ’I=’, i, ’ J=’, j, ’ Sum=’, j + i
9 end do inner_loop
10 end do outer_loop
11 end program aninhado

Programação Concorrente com Loops 016_concorrente
A paralelização real depende do compilador e do hardware
1 program concorrente
2 real , parameter :: pi = 3.14159265
3 integer , parameter :: n = 10
4 real :: result_sin(n)
5 integer :: i
6 do concurrent (i = 1:n) ! Careful , the syntax is
slightly different
7 result_sin(i) = sin(i * pi /4.)
8 end do
9 print *, ’resultados de cada loop ’, result_sin
10 end program concorrente

Subrotinas e Funções 017_subrotinas
Subrotinas são chamadas com call e funções são chamadas diretamente
em expressões que usam um valor retornado da função
1 subroutine print_matrix(n,m,A)
2 implicit none
3 integer , intent(in) :: n
4 integer , intent(in) :: m
5 real , intent(in) :: A(n, m)
6 integer :: i
7 do i = 1, n
8 print *, A(i, 1:m)
9 end do
10 end subroutine print_matrix

Subrotinas e Funções 017_subrotinas
Subrotinas são chamadas com call e funções são chamadas diretamente
em expressões que usam um valor retornado da função
1 program call_sub
2 implicit none
3 real :: mat(10, 20)
4 mat (:,:) = 0.0
5 call print_matrix (10, 20, mat)
6 end program call_sub
Intent indica o tipo de argumento: read-only(intent(in))
write-only(intent(out)) or read-write(intent(inout))

Subrotinas e Funções 018_funcoes
Exemplo de função
1 function vector_norm(n,vec) result(norm)
2 implicit none
3 integer , intent(in) :: n
4 real , intent(in) :: vec(n)
5 real :: norm
6 norm = sqrt(sum(vec **2))
7 end function vector_norm

Subrotinas e Funções 018_funcoes
Chamando a função.
1 program run_fcn
2 implicit none
3 real :: v(9)
4 real :: vector_norm
5 v(:) = 9
6 print *, ’Vector norm = ’, vector_norm (9,v)
7 end program run_fcn

Módulos
Módulos em Fortran contêm definições que são tornadas acessíveis para
programas, procedimentos e outros módulos por meio do uso da
declaração "use". Eles podem conter objetos de dados, definições de tipos,
procedimentos e interfaces.

Modulos 019_modulos
1 module my_mod
2 private ! All entities are now module -private by
default
3 public public_var , print_matrix ! Explicitly
export public entities
4 real , parameter :: public_var = 2
5 integer :: private_var
6 contains
7 subroutine print_matrix(A)
8 real , intent(in) :: A(:,:) ! An assumed -shape
dummy argument
9 integer :: i
10 do i = 1, size(A,1)
11 print *, A(i,:)
12 end do
13 end subroutine print_matrix
14 end module my_mod

Usando Modulos 020_usamodulo
Compilar: gfortran -c 019_modulos.f90 020_usamodulo.f90
Linker: gfortran -c 019_modulos.o 020_usamodulo.o -o mod
1 program use_mod
2 use my_mod
3 implicit none
4 real :: mat(10, 10)
5 mat (:,:) = public_var
6 call print_matrix(mat)
7 end program use_mod

Importações Explícitas
Importação de um conjunto de elementos explícitos pode ser feito assim:
use my_mod, only: public_var
Usando aliases
use my_mod, only: printMat=>print_matrix

Tipos Derivados
Existem cinco tipos de dados incorporados no Fortran. Um tipo derivado é
uma forma especial de tipo de dados que pode encapsular outros tipos de
dados incorporados, bem como outros tipos derivados. Pode ser
considerado equivalente ao "struct"nas linguagens de programação C e
C++.

Exemplo de Tipo Derivado
1 type :: t_pair
2 integer :: i
3 real :: x
4 end type

Declarando Variáveis de Tipo Derivado
Como declarar as variáveis e ter acesso aos membros.
1 ! Declare
2 type(t_pair) :: pair
3 ! Initialize
4 pair%i = 1
5 pair%x = 0.5
O símbolo de porcentagem (%) é usado para acessar os membros de um
tipo derivado.No trecho acima, declaramos uma instância de um tipo
derivado e inicializamos seus membros explicitamente. Você também pode
inicializar os membros do tipo derivado invocando o construtor do tipo
derivado.

Construtores de Tipos Derivados
Inicializações
1 pair = t_pair (1, 0.5) ! Com argumentos
posicionais
2 pair = t_pair(i=1, x=0.5) ! Usando keywords
3 pair = t_pair(x=0.5, i=1) ! Keywords podem vir
em qualquer ordem
Exemplos com inicialização default
1 type :: t_pair
2 integer :: i = 1
3 real :: x = 0.5
4 end type
6 pair = t_pair () ! pair%i é 1, pair%x é 0.5
7 pair = t_pair(i=2) ! pair%i é 2, pair%x é 0.5
8 pair = t_pair(x=2.7) ! pair%i é 1, pair%x é 2.7

Sintaxe Geral dos Tipos Derivados
Sintaxe geral para a definição de tipos derivados é:
1 type [,attribute -list] :: name
[( parameterized -declaration -list)]
2 [parameterized -definition -statements]
3 [private statement or sequence statement]
4 [member -variables]
5 contains
6 [type -bound -procedures]
7 end type

Lista de Atributos attribute-list
A lista de atributos pode se referir aos seguintes elementos:
access-type, que pode ser público ou privado.
bind(c), oferece interoperabilidade com a linguagem de programação
C.
extends(parent), onde parent é o nome de um tipo derivado
previamente declarado, do qual o tipo derivado atual herdará todos os
seus membros e funcionalidades.
abstract, que é um recurso de programação orientada a objetos
abordado no tutorial avançado de programação.
Se o atributo bind(c) ou a sequência de declaração for usada, então um
tipo derivado não pode ter o atributo extends, e vice-versa.

Atributo sequence
O atributo sequence só pode ser usado para declarar que os membros
seguintes devem ser acessados na mesma ordem em que são definidos
dentro do tipo derivado.
Exemplo com sequence:
1 type :: t_pair
2 sequence
3 integer :: i
4 real :: x
5 end type
6 ! Initialize
8 pair = t_pair (1, 0.5)

Atributos public e private
Os atributos de acesso public e private, se utilizados, declaram que todas
as variáveis membros declaradas abaixo serão automaticamente atribuídas
ao atributo correspondente.

bind
O atributo bind(c) é usado para alcançar compatibilidade entre o tipo
derivado do Fortran e a estrutura (struct) do C.
Exemplo:
1 module f_to_c
2 use iso_c_bindings , only: c_int
3 implicit none
4 type , bind(c) :: f_type
5 integer(c_int) :: i
6 end type
7 end module f_to_c
Casa com a estrutura C abaixo:
1 struct c_struct {
2 int i;
3 };

parameterized-declaration-list
A lista de declarações parametrizadas é um recurso opcional. Se utilizado,
os parâmetros devem ser listados no lugar das
[parameterized-definition-statements] e devem ser parâmetros len, kind ou
ambos.
Exemplo:
1 module m_matrix
2 implicit none
3 private
4 type , public :: t_matrix(rows , cols , k)
5 integer , len :: rows , cols
6 integer , kind :: k = kind (0.0)
7 real(kind=k), dimension(rows , cols) :: values
8 end type
9 end module m_matrix
10 program test_matrix
11 use m_matrix
12 implicit none
13 type(t_matrix(rows=5, cols =5)) :: m

parameterized-declaration-list
No exemplo anterior, o parâmetro k já foi atribuído um valor padrão de
kind(0.0) (ponto flutuante de precisão simples). Portanto, ele pode ser
omitido, como é o caso aqui na declaração dentro do programa principal.
Se o tipo t_matrix não tivesse recebido o atributo public no exemplo
acima, o compilador geraria um erro dentro do programa test.

Extends
O atributo extends foi adicionado no padrão F2003 e introduz um recurso
importante do paradigma de orientação a objetos (OOP), conhecido como
herança. Ele permite a reutilização de código ao permitir que tipos
derivados (filhos) sejam derivados de tipos pai extensíveis: type,
extends(parent) :: child. Nesse caso, child herda todos os membros e
funcionalidades do tipo parent.

Exemplo de Uso do Extends 021_extends
1 module m_employee
2 private
3 public t_date , t_address , t_person , t_employee
4 ! another way of using the public attribute:
5 ! gathering all public data types in one place.
6 type :: t_date
7 integer :: year , month , day
8 end type
9 type :: t_address
10 character(len =:), allocatable :: city ,
road_name
11 integer :: house_number
12 end type

1 type , extends(t_address) :: t_person
2 character(len =:), allocatable :: first_name ,
last_name , e_mail
3 end type
4 type , extends(t_person) :: t_employee
5 type(t_date) :: hired_date
6 character(len =:), allocatable :: position
7 real :: monthly_salary
8 end type
9 end module m_employee

1 program test_employee
2 use m_employee
3 implicit none
4 type(t_employee) :: employee
5 ! Initialization
6 ! t_employee has access to type(t_date) members
not because of extends
7 ! but because a type(t_date) was declared within
t_employee.
8 employee%hired_date%year = 2020
9 employee%hired_date%month = 1
10 employee%hired_date%day = 20
11 ! t_employee has access to t_person , and inherits
its members due to extends.
12 employee%first_name = ’John ’
13 employee%last_name = ’Doe’

1 ! t_employee has access to t_address , because it
inherits from t_person ,
2 ! which in return inherits from t_address.
3 employee%city = ’London ’
4 employee%road_name = ’BigBen ’
5 employee%house_number = 1
6 ! t_employee has access to its defined members.
7 employee%position = ’Intern ’
8 employee% monthly_salary = 0.0
9 print *, employee%first_name , employee%last_name
10 end program test_employee

Variáveis Membro
[member-variables] refere-se à declaração de todos os tipos de dados
membros. Esses tipos de dados podem ser de qualquer tipo de dado
incorporado e/ou de outros tipos derivados, como já demonstrado nos
exemplos acima. No entanto, as [member-variables] podem ter sua própria
sintaxe extensiva, na forma de: type [,member-attributes] ::
name[attr-dependent-spec][init].

Atributos Membros
[,member-attributes] podem ser:
atributos de acesso: public or private
atributo de acesso protected
matriz dinâmica alocável com ou sem dimensão
pointer, codimension, contiguous, volatile, asynchronous (a pesquisar)

Exemplo de Uso de Atributos Membros
1 type :: t_example
2 ! 1st case: simple built -in type with access
attribute and [init]
3 integer , private :: i = 0
4 ! private hides it from use outside of the
t_example ’s scope.
5 ! The default initialization [=0] is the [init]
part.
6 ! 2nd case: protected
7 integer , protected :: i
8 ! In contrary to private , protected allows access
to i assigned value outside of t_example
9 ! but is not definable , i.e. a value may be
assigned to i only within t_example.

Exemplo de Uso de Atributos Membros
1 ! 3rd case: dynamic 1-D array
2 real , allocatable , dimension (:) :: x
3 ! the same as
4 real , allocatable :: x(:)
5 ! This parentheses ’ usage implies dimension (:) and
is one of the possible [attr -dependent -spec ].
6 end type

Procedimentos vinculados a tipos (Type-bound procedures)
Um tipo derivado pode conter funções ou sub-rotinas que estão vinculadas
a ele. Nos referiremos a elas como procedimentos vinculados a tipos
(type-bound procedures). Os procedimentos vinculados a tipos seguem a
declaração contains que, por sua vez, segue todas as declarações de
variáveis membros.
É impossível descrever completamente os procedimentos vinculados a tipos
sem mergulhar nos recursos de programação orientada a objetos (OOP) do
Fortran moderno. Por enquanto, vamos nos concentrar em um exemplo
simples para mostrar o uso básico deles.

Exemplo tBound 022_tbound
1 module m_shapes
2 implicit none
3 private
4 public t_square
5 type :: t_square
6 real :: side
7 contains
8 procedure :: area ! procedure declaration
9 end type
10 contains
11 ! Procedure definition
12 real function area(self) result(res)
13 class(t_square), intent(in) :: self
14 res = self%side **2
15 end function
16 end module m_shapes

Exemplo tBound 022_tbound
1 program main
2 use m_shapes
3 implicit none
4 ! Variables ’ declaration
5 type(t_square) :: sq
6 real :: x, side
7 ! Variables ’ initialization
8 side = 0.5
9 sq%side = side
10 x = sq%area ()
11 ! self does not appear here , it has been passed
implicitly
12 ! Do stuff with x...
13 print *, x
14 end program main

Self e Class
"Self"é um nome arbitrário que escolhemos para representar a instância do
tipo derivado t_square dentro da função vinculada ao tipo. Isso nos
permite acessar seus membros e passá-lo automaticamente como um
argumento quando invocamos um procedimento vinculado ao tipo.
Agora usamos "class(t_square)"em vez de "type(t_square)"na interface da
função "area". Isso nos permite invocar a função "area"com qualquer tipo
derivado que estenda "t_square". A palavra-chave "class"introduz o
recurso de programação orientada a objetos (OOP) chamado polimorfismo.

Arquivos em Fortran
Mostrar como gravar e ler arquivos em Fortran falta elaborar os exercícios
....

Gerando Gráficos com Gnuplot
Informações sobre o pacote gnuplot
http://gnuplot.info/docs_5.5/Overview.html
Instalar no lixux
sudo apt install gnuplot
Rodando
gnuplot -s

Usando Interativamente
1 gnuplot > plot(sin(x))
2 gnuplot > plot(cos(x))
3 gnuplot > plot(tan(x))
4 gnuplot > plot (5*x**2 - 2*x - 50)
Resultados:

Comandos Básicos
set grid, set nogrid, set xrange[], set yrange[], set zrange[], etc.. Tutorial
completo
https://www2.fct.unesp.br/docentes/carto/galo/web/gnuplot/
pdf/2017_Galo_Gnuplot_Tutorial.pdf

Scripts
1 reset
2 set grid
3 set format z "4.2f"
4 f(x,y) = log(sqrt(x**2 + y**2))
5 splot f(x,y)
Rodando o Script:
gnuplot -p -s -c script2:
Resuldado:

Chamando o Gnuplot em uma programa Fortran
Gerar os dados e chamar o gnuplot para imprimir os dados
1 call execute_command_line (’gnuplot -p ’ // PLT_FILE)
Ver programa 023_plot.f90

O Problema da Média
A média aritmética de um conjunto de números é dada pela fórmula:
x =
1
n
n
X
i=1
xi
Agora imaginemos um processo de recepção de dados contínuos como um
sensor físico que captura dados com ruído. O total de operações realizadas
cresce segundo a tebela abaixo
Elementos Adições Elementos Adições
1 0 6 15
2 1 7 21
3 3 8 29
4 6 9 37
5 10 10 46
Adições acumuladas (atual + anterior)

Evolução do Número de Operações em Série
024_analiseMedia.f90

Solução - Média Móvel Recursiva
x =
x1 + x2 + ... + xn−1 + xn
n
(1)
Daí:
nx = x1 + x2 + ... + xn−1 + xn (2)
Dividindo tudo por n − 1 teremos:
n
n − 1
x =
x1 + x2 + ... + xn−1
n − 1
+
xn
n − 1
(3)
Observe o primeiro termo do lado direito da equação equivale à uma
média calculada previamente xn−1 , então:

Fórmula Recursiva da Média
n
n − 1
x = xn−1 +
xn
n − 1
(4)
Daí deduzimos o valor da média:
x =
n − 1
n
xn−1 +
n − 1
n
xn
n − 1
(5)
ou
x =

1 −
1
n

xn−1 +
1
n
xn (6)
Podemos decompor em :
α = 1 −
1
n
; x = αxn−1 + (1 − α)xn (7)
Ao isolarmos o valor de α de n estaremos criando um parâmetro para um
filtro passa baixa. No caso de mantermos a dependência criamos um filtro
para suavização por média móvel.

Resultado 025_filtro_media

Trabalhando Sério
O problema da namorada(o) ciumenta(o). Uma pessoa sai no seu
carro para casa de familiares, o trajeto é conhecido e a velocidade média
na cidade é de 50 km/h. Além disso seu parceiro(a) com ciúmes instalou
um rastreador no carro que envia a localização periodicamente. O
rastreador não é 100% preciso e em algumas áreas pode não funcionar
bem. Como saber a cada momento onde está o carro e sua velocidade?

Filtro de Kalman
Pré-requisitos:
Conhecer a distribuição de probabilidades dos erros dos sensores
Ter um modelo matemático aproximado de cálculo de predição do
estado (Leis de Newton por exemplo)

Algoritmo do Filtro de Kalman
Algorithm 1: Filtro de Kalman
Data: Z: Medidas dos Sensores, M(A, H, Q, R, etc):Modelo Sistema
Result: X̂: Estimativa do Estado
// Passo 0: Inicializa os Dados ˆ
x0, P0
1 while True do
// Passo 1: Prever Estado e Matriz de Covariância de
Erros
// Passo 2: Calcular o Ganho(Kalman Gain)
// Passo 3: Calcular o valores estimados
// Passo 4: Calcular covariâncias de erros
2 end

P1 - Prevendo os Dados e Matriz de Covariância
x̂−
k = Ax̂k−1 (8)
P−
k = APk−1AT
+ Q (9)
Onde:
k - tempo discreto t = k
xk - valor real do estado(desconhecido) ∼ N(x̂k, Pk)
x̂k - melhor estimativa possível para xk
x̂−
k - previsão de x̂k antes de realizar ou obter as medidas dos sensores
A - Matriz usada para calcular o estado físico do processo (Modelo)
Q - Matriz usada juntamente com R(a seguir) quantificam o ruído
Pk - Matriz de Covariâncias

P2 - Calculando o Ganho de Kalman
Kk = P−
k HT
(HP−
k HT
+ R)−1
(10)
onde:
Kk - Ganho de Kalman no tempo k.
H - Matriz que correlaciona as medidas com o estado

P3 - Construindo o Estimador
x̂k = x̂−
k + ganho ajustado (11)
x̂k = x̂−
k + Kk(zk − Hx̂−
k ) (12)
Onde:
xk é uma matriz (n x 1). O termo Hx̂−
k é considerado como a medição
prevista em contraposto a zk que é efetivamente a medida realizada.

Continuando
x̂k = x̂−
k + Kk(zk − Hx̂−
k ) (13)
x̂k = x̂−
k + Kkzk − KkHx̂−
k (14)
daí:
x̂k = (1 − KkH)x̂−
k + Kkzk (15)
Supondo razoavelmente que H = 1 teremos:
x̂k = (1 − Kk)x̂−
k + Kkzk (16)
Seja α = 1 − Kk então:
x̂k = αx̂−
k + (1 − α)zk (17)

Moral da História
O filtro de Kalman se assemelha a um filtro passa baixa com o valor de α
(ganho) mudando ao longo do tempo (dinamicamente)

P4 - Atualizando as Covariâncias
Pk = P−
k KkHP−
k (18)
A matriz de covariância dos erros é uma medida da inacuracidade do
estimador. Assume-se que xk segue uma distribuição normal com média x̂k
e covariância dada por Pk

Voltando a P1 - Predição
A predição antes da medida do ambiente é dada por:
x̂−
k = Ax̂k−1 (19)
Este elemento pode ser chamado de estimação ’a priori’ ou simplesmente
estimação. A é uma matriz (n x n) e x̂k−1 é o valor predito no passo
anterior.
A matriz de covariâncias é atualizada por:
P−
k = APk−1AT
+ Q (20)
Aqui a matriz Q é chamada de ’ruido do processo’ ou ’ruido de transição
de estado’

Filtro de Kalman - Esquema do Processo

Modelo do Sistema Físico
O modelo físico é expresso através das matrizes A,H,Q e R
A Atualização do Estado é dado por:
xk+1 = Axk + wk (21)
Onde wk é o ruído no processo físico
A atualização das medidas realizadas é dada pela equação
zk+1 = Hxk + vk (22)
Onde vk é o ruído na medida.

Análise Dimensional
Variável Descrição Dimensão
xk uma variável de estado - vetor coluna (n x 1)
zk uma medida - vetor coluna (m x 1)
A matriz de transição de estado - matriz quadrada (n x n)
H matriz que relaciona estado com medida - matriz (m x n)
wk o ruído de transição de estado - vetor coluna (n x 1)
vk o ruído na medida. - vetor coluna (n x 1)
Q Matriz de covariãncias de wk -matriz diagonal (n x n)
R Matriz de covariâncias de vk - matriz Diagonal (m x m)
O ruído da medida vk pode ser fornecido pelo fabricante do sensor.

Ruído W e Variância
O ruído w é dado por:
wk =





w1
k
w2
k
...
wn
k





→ (nuído em )





x1
k
x2
k
...
xn
k





→ (variâncias)





σ2
1
σ2
2
...
σ2
n





(23)
A matriz Q será:
Q =





σ2
1 0 ... 0
0 σ2
2 ... 0
... ... ... ...
0 0 0 ...σ2
n





(24)
A matriz R terá forma similar e poderá ser fornecida pelas especificações
do fabricante do sensor

Exemplo Super Simples
Considerar uma bateria recém fabricada. A expectativa é que tenha uma
voltagem constante, mas as medidas feitas com o multímetro oscilam.
Qual a melhor previsão que podemos fazer da voltagem real da bateria?

Modelando o Problema da Bateria
Seja z a medida (tensão) feita na bateria porém tem ruído.
Seja x o estado que desejamos prever, no caso também é a tensão. Vamos
assumir que não haja ruído no processo
Os valores de m e n serão 1 pois só temos uma medida e um valor de
estado.
Imaginamos que o estado real (tensão) permanece a mesma ao longo do
tempo, logo:
xk+1 = xk ⇒ A = 1 (25)
A medida (ruidosa) diferirá do estado real por um fator de ruído:
zk = xk + vk (26)

Continuando
Deduzimos do exposto até que:
A = 1, H = 1, Q = 0 (Sem ruído)
Vamos agora chutar um valor para R por exemplo R = 4 (chute no ruído
da medida(variância na medida)) Precisamos também chutar o valor inicial
da tensão e da incerteza desse valor. x−
0 = 14 P−
0 = 6

Simulando a Medida
Vamos precisar de uma função para simular a realização da medida.
1 function getVolts( ) result(tensao)
2 implicit none
3 real ::tensao , rand_num , v
4 call random_number(rand_num)
5 v = 8 * rand_num - 4
6 tensao = 14.4 + v
7 end function getVolts

Rotinas Auxiliares
1 subroutine grava_dados(n,k,x,y,arq)
2 implicit none
3 integer , intent(in) :: N
4 real , intent(in) :: k(n), x(N), y(N)
5 character(len =*)::arq
6 integer :: i, fu
7 open (action=’write ’, file=arq , newunit=fu ,
status=’replace ’)
8 do i = 1, N
9 write (fu , *) k(i),x(i),y(i)
10 end do
11 close(fu)
12 end subroutine grava_dados
13 subroutine plota_resultados (arq)
14 character(len =*)::arq
15 call execute_command_line (’gnuplot -p ’ // arq)
16 end subroutine plota_resultados

Kalman Simples
1 program kalman_simples
2 implicit none
3 integer ::i
4 character(len =*), parameter :: OUT_FILE =
’data_volts.txt’ ! Output file.
5 character(len =*), parameter :: PLT_FILE =
’plot_volts.plt’ ! Gnuplot file.
6 integer ,parameter ::N=40 ! N[umero de medidas]
7 real :: getVolts
8 real :: Tempos(N),Medidas(N),Previsoes(N)
9 !Inicializando o filtro de kalman
10 real ::A=1.0
11 real ::H=1.0
12 real ::Q=0.0
13 real ::R=8.0
14 real ::x=14.0
15 real ::P=6.0
16 end program kalman_simples

Kalman Simples
1 real ::xp ,pp ,K,z
2 do i=1,N
3 xp = A * x ! predicao do estimador
4 pp = A * P * A + Q ! preodição da covariancia do
erro
5 ! originalmente seria a transposta de A =
transpose(A)
6 ! em matlab pp = A * P * A’ + Q
7 K = pp * H * 1/(H * pp * H + R) ! calculo do
ganho kalman
8 ! originalmente seria em matlab K =
Pp*H’*inv(H*Pp*H’ + R)
9 z = getVolts ()

Kalman Simples
1 x = xp + K*(z - H*xp)
2 pp = pp - K* H * pp
3 Tempos(i) = i
4 Medidas(i) = z
5 Previsoes(i) = x ! volts calculados
6 end do
7 call
grava_dados(N,Tempos ,Medidas ,Previsoes ,OUT_FILE)
8 call plota_resultados (PLT_FILE)
9 end program kalman_simples

Resultado

Fim da Parte II.
(A parte a seguir é opcional e não está concluída)

Complicando Um Pouco
Estimando a Velocidade e a Posição
xk =

Posicao
Velocidade
#
k
, xk+1 = Axk + wk
As medidas ruidosas serão:
zk = Hxk + vk
Onde:
A =

1 ∆t
0 1
#
, H =
h
1 0
i
∆t é tempo decorrido entre medidas.

Continuando a complicação
Predição da Posição e da velocidade.
xk+1 =

Posicao
Velocidade
#
k+1
=

1 ∆t
0 1
#
Posicao
Velocidade
#
k
=

Posicaok + ∆t ∗ Velocidadek
Velocidadek
#

Ruídos
Medidas Ruidosas seriam:
zk = Hxk + vk = [1 0]

Posicao
Velocidade
#
k
+ vk
Ruído do Processo seria(chute):
Q =

1 0
0 3
#
, R = 10

Dados Iniciais
X−
0 =

0
20
#
, P−
0 =

5 0
0 5
#

paradigmas_de_programacao_2_X.pdf

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a paradigmas_de_programacao_2_X.pdf

Semelhante a paradigmas_de_programacao_2_X.pdf (20)

Mais de ronaldo ramos

Mais de ronaldo ramos (20)

Último

Último (20)

paradigmas_de_programacao_2_X.pdf