O documento discute os paradigmas de programação imperativo e estruturado, apresentando as linguagens BASIC e FORTRAN como exemplos históricos. Inclui detalhes sobre recursos, comandos, variáveis, entrada/saída e exemplos de código nas duas linguagens.
2. 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
3. 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/
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 3 / 121
4. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 4 / 121
5. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 5 / 121
6. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 6 / 121
7. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 7 / 121
8. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 8 / 121
10. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 10 / 121
11. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 11 / 121
12. Aplicação em Física
Simulação Hidro Magnético Relativística do Crescimento de Um Buraco
Negro
Feito em Fortran. (wikipedia)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 12 / 121
13. Aplicações em Física
Feito em Fortran Animação em
https://en.wikipedia.org/wiki/File:Cylinder_flow.gif
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 13 / 121
14. GFortran
Instalar Localmente
sudo apt install gfortran
https:
//fortran-lang.org/en/learn/os_setup/install_gfortran/
Programar Online
https://play.fortran-lang.org/
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 14 / 121
15. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 15 / 121
16. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 16 / 121
17. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 17 / 121
18. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 18 / 121
19. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 19 / 121
20. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 20 / 121
21. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 21 / 121
22. Operadores Aritméticos
Operator Descrição
** Exponenciação
* Multiplicação
/ Divisão
+ Adição
- Subtração
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 22 / 121
23. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 23 / 121
24. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 24 / 121
25. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 25 / 121
26. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 26 / 121
27. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 27 / 121
28. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 28 / 121
29. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 29 / 121
30. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 30 / 121
31. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 31 / 121
32. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 32 / 121
33. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 33 / 121
34. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 34 / 121
35. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 35 / 121
36. 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_
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 36 / 121
37. Quebra de Paradigma
A partir das experiências de programação primitivas com Fortran, Cobol,
PLI, Basic desenvolve-se a programação estruturada.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 37 / 121
38. PARTE 2.1 - PARADIGMA IMPERATIVO
PROGRAMAÇÃO ESTRUTURADA
PROGRAMAÇÃO SEM GOTO
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 38 / 121
39. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 39 / 121
40. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 40 / 121
41. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 41 / 121
42. Origens e Influências das LPs
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 42 / 121
43. Continuando com o Fortran Estruturado
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 43 / 121
44. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 44 / 121
45. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 45 / 121
46. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 46 / 121
47. 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_
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 47 / 121
48. 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_
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 48 / 121
49. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 49 / 121
50. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 50 / 121
51. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 51 / 121
52. 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))
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 52 / 121
53. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 53 / 121
54. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 54 / 121
55. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 55 / 121
56. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 56 / 121
57. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 57 / 121
58. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 58 / 121
59. 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++.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 59 / 121
60. Exemplo de Tipo Derivado
1 type :: t_pair
2 integer :: i
3 real :: x
4 end type
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 60 / 121
61. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 61 / 121
62. 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
5 type(t_pair) :: pair
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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 62 / 121
63. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 63 / 121
64. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 64 / 121
65. 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
7 type(t_pair) :: pair
8 pair = t_pair (1, 0.5)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 65 / 121
66. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 66 / 121
67. 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 };
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 67 / 121
68. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 68 / 121
69. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 69 / 121
70. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 70 / 121
71. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 71 / 121
72. Exemplo de Uso do Extends 021_extends
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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 72 / 121
73. Exemplo de Uso do Extends 021_extends
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’
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 73 / 121
74. Exemplo de Uso do Extends 021_extends
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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 74 / 121
75. 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].
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 75 / 121
76. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 76 / 121
77. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 77 / 121
78. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 78 / 121
79. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 79 / 121
80. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 80 / 121
81. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 81 / 121
82. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 82 / 121
83. Arquivos em Fortran
Mostrar como gravar e ler arquivos em Fortran falta elaborar os exercícios
....
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 83 / 121
84. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 84 / 121
85. 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:
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 85 / 121
86. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 86 / 121
87. 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:
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 87 / 121
88. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 88 / 121
89. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 89 / 121
90. Evolução do Número de Operações em Série
024_analiseMedia.f90
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 90 / 121
91. 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:
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 91 / 121
92. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 92 / 121
94. 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?
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 94 / 121
95. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 95 / 121
96. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 96 / 121
97. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 97 / 121
98. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 98 / 121
99. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 99 / 121
100. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 100 / 121
101. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 101 / 121
102. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 102 / 121
103. 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’
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 103 / 121
104. Filtro de Kalman - Esquema do Processo
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 104 / 121
105. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 105 / 121
106. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 106 / 121
107. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 107 / 121
108. 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?
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 108 / 121
109. 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)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 109 / 121
110. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 110 / 121
111. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 111 / 121
112. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 112 / 121
113. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 113 / 121
114. 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 ()
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 114 / 121
115. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 115 / 121
116. Resultado
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 116 / 121
117. Fim da Parte II.
(A parte a seguir é opcional e não está concluída)
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 117 / 121
118. 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.
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 118 / 121
119. 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
#
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 119 / 121
120. 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
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 120 / 121
121. Dados Iniciais
X−
0 =
0
20
#
, P−
0 =
5 0
0 5
#
Ronaldo F. Ramos (Instituto Federal do Ceará) Paradigmas de Programação 6 de agosto de 2023 121 / 121