LIP20 - Matrizes

20
Matrizes
Linguagens de Programação
Tipo Básico vs Tipo Composto
▪ Tipo Básico
– fornecido por uma linguagem
de programação como um
bloco de construção básico
▪ Tipo Composto
– pode ser construído a partir
de tipos primitivos e de
outros tipos compostos, em
um processo chamado
composição.
Definição de Matriz
▪ “Composição homogênea de dados, cujo elemento individual
é identificado por sua posição relativa ao primeiro”
double notas[30]; Matriz

Matriz Índice
Índice
== ==
Vetor
Vetor Subscrito
Subscrito
notas[5] = 8.5; ==
Array
Array
notas 8.5
0 1 2 3 4 5 ... 28 29
<tipo> <nome>[<dim1>][<dim2>];
<tipo> <nome>[<dim1>][<dim2>]...[<dimN>];
7 dimensões tá bom!
Não?!
Matrizes e Índices
▪ Uma referência a um elemento inclui um ou mais índices que
determinam sua localização
– Esses índices normalmente são números inteiros
▪ A sintaxe mais comum para referência a Matrizes é usando
colchetes
real :: numeros(5)
integer :: matriz(3,3)
int A[10]; ...
float B[4][3]; matriz(i, j) = i+j
char C[40];
... a : array (1..1000) of integer;
A[2] = 3;
B[0][0] = 2.5; for i in 1..1000 loop
C[20] = '\n'; a(i) := 0;
end loop;
Matrizes e Índices
▪ Índices geralmente são faixas de inteiros
Inicia de zero Inicia de um

Matrizes e Índices
– Algumas linguagens permitem faixas de inteiros quaisquer como
índices
A: array(-4..5) of INTEGER;
B: array(1..4,0..2) of FLOAT;
C: array(1..40) of CHARACTER;
Matrizes e Índices
– Algumas linguagens permitem qualquer tipo ordinal como índice
procedure Relatorio is
type Meses is (Jan, Feb, Mar, Apr, May, Jun,
Jul, Aug, Sep, Oct, Nov, Dec);
type Vendas is array (Meses) of FLOAT;
Ano2020 : Vendas;
begin
...
for I in Meses loop
Put (Ano2020 (I));
end loop;
end Relatorio;
Matrizes e Índices
– Algumas linguagens permitem índices negativos para acessar na
ordem inversa
my @lista = ('A','B','C','D','E');
$lista[-2] = 'Z';
foreach my $n (@names) {
say $n;
}
A B C Z E
Inicialização de Matrizes
▪ Em algumas linguagens, todos os elementos de uma matriz
são predefinidos automaticamente
▪ int, float, double… → zero

▪ char → ‘\u0000’
▪ referências a objetos → null
▪ boolean → false
▪ Algumas linguagens permitem a inicialização de matrizes
durante a alocação
INTEGER LISTA(4)
DATA LISTA /4, 5, 7, 83/
int lista[] = {4, 5, 7, 83};

char nome[] = "Programação";

char *nomes[] = { String[] nomes = {

"Ana", "Ana",
"Julia" "Julia"
}; };
LISTA: array (1..5) of INTEGER := (1, 3, 5, 7, 9);

GRUPO: array (1..5) of INTEGER := (1 => 3, 3 => 4, others => 0);
Atribuição
Atribuiçãodireta
diretaaaelementos
elementosespecíficos
específicosda
damatriz
matriz
2
Compreensão
Compreensãode
deListas
Listas Δ={x ∣ x ∈ [0,10], x é divisível por 3}
lista = [x*x for x in range(0,10) if x % 3 == 0]
lista = [0,9,36,81]
lista = [x*x | x <- [0..10], mod x 3 == 0]

Fatias
▪ Sequência contínua de entradas de uma matriz
P = "python"
Início (inclusive)
P[0:2] ↔ 'py' 'py'
Final (exclusive) P[0:3] ↔ 'py' 'pyt'
P[3:4] ↔ 'py' 'h'
P[3:] ↔ 'py' 'hon'
P[a:b] P[:4] ↔ 'py' 'pyth'
Fatias
MAT(1:3, 1:3)
Fatias
MAT(2, 1:3)
MAT(1:3, 1:3)
Fatias
MAT(1:3, 1:2)
MAT(1:3, 1:3)
MAT(1:3, 1:3, 1:4)
Fatias
MAT(2, 1:3, 1:4)
MAT(1:3, 1:3, 1:4)

Fatias
MAT(1:3, 1:3, 2:3)
MAT(1:3, 1:3, 1:4)

Fatias
▪ Sequência “contínua” de entradas de uma matriz
LISTA: array (1..5) of INTEGER := (10, 3, 42, 18, 50);

...
LISTA((/3, 1, 4/)) ↔ 'py' (42,10,18)
Listas
▪ Matriz heterogênea
B = [42, 3.14, 'ola', 'R2D2']

Categorias de Matrizes
▪ Matriz estática Pilha
▪ Matriz pilha-dinâmica fixa
▪ Matriz pilha-dinâmica
▪ Matriz heap-dinâmica fixa Heap
▪ Matriz heap-dinâmica Dados Estáticos
Código
Tamanho do Vetor (fixo ou variável)

Tipo de Alocação
Local de Armazenamento
▪ Matriz estática
– Índices fixos
– Alocação estática
– Vantagem: eficiência de alocação
– Desvantagem: ativo durante todo o programa
int vet[10];
void f(){
static int mat[4][4];
...
}
int main(){
...
}
▪ Matriz pilha-dinâmica fixa
– Índices fixos
– Alocação de acordo com alocação dinâmica de funções
– Vantagem: eficiência quanto ao espaço
– Desvantagem: tempo de alocação
void f(){
int mat[4][4];
...
}
int main(){
...
}
▪ Matriz pilha-dinâmica
– Índices dinâmicos
– Alocação de acordo com alocação dinâmica de funções
– Vantagem: flexibilidade no tamanho
void f(int n){
int mat[n][n];
...
}
int main(){
...
}
▪ Matriz heap-dinâmica fixa
– Índices e alocação são dinâmicas
– Tamanho é fixo depois de alocado
– Vantagem: flexibilidade de criar matrizes não temporárias
void f(int n){
int *vet = (int*)malloc(n*sizeof(int));
...
free(vet);
}
int main(){
...
}
▪ Matriz heap-dinâmica
– Índices e alocação são dinâmicas
– Tamanho pode mudar no decorrer da execução
– Vantagem: possibilidade de variar o tamanho da matriz
#include <vector>
void f(int n){

std::vector<int> vet;
...
}
int main(){
...
}
▪ Comparativo
Categoria Tamanho Tempo de Definição Alocação Local de Alocação

Estática Fixo Compilação Estática Dados Estáticos
Pilha-dinâmica fixa Fixo Compilação Dinâmica Pilha
Pilha-dinâmica +/- Fixo Execução Dinâmica Pilha
Heap-dinâmica fixa +/- Fixo Execução Dinâmica Heap
Heap-dinâmica Variável Execução Dinâmica Heap
▪ Comparativo

▪ Comparativo

▪ Comparativo

Implementação de Matrizes
▪ O que acontece numa atribuição como essa…
int x;
...
x = 10; “O endereço de x recebe o valor 10”
▪ E o que acontece nessa atribuição?
int i;
int vet[5];
...
vet[i] = 10; “O endereço de vet[i] recebe o valor 10”

“Qual é o endereço de vet[i]?”
▪ Na fase semântica, um compilador constrói um bloco de
informações pra cada matriz
Tipo do elemento da matriz
Tamanho do elemento da matriz

Descritor da Matriz
Tipo do índice pra cada dimensão
Faixa ou tamanho dos índices de cada dimensão
int A[10]; A: array(-4..5) of INTEGER;

float B[4][3]; type Vendas is array (Meses) of FLOAT;
char C[40]; Ano2020: Vendas;
▪ Uma matriz unidimensional é uma lista de células de
memória adjacentes
int vet[5] ↔ 'py' int *vet = malloc(5*sizeof(int)) 0x7ffd77045730 = 02 0000 0010
0x7ffd77045731 = 00 0000 0000
0x7ffd77045732 = 00 0000 0000
vet[2] ↔ 'py' &vet[0] + 2*sizeof(int) 0x7ffd77045733 = 00 0000 0000
0x7ffd77045734 = 01 0000 0001
0x7ffd77045735 = 01 0000 0001
0x7ffd77045736 = 00 0000 0000
int vet[] = {2,257,1025,48}; 0x7ffd77045737 = 00 0000 0000
int i; 0x7ffd77045738 = 01 0000 0001
void *byte; 0x7ffd77045739 = 04 0000 0100
0x7ffd7704573a = 00 0000 0000
byte = vet; 0x7ffd7704573b = 00 0000 0000
for(i = 0; i < 4*sizeof(int) ; i++){ 0x7ffd7704573c = 30 0001 1110
printf("%p = %02x\n",byte,*((char*)byte)); 0x7ffd7704573d = 00 0000 0000
byte++; 0x7ffd7704573e = 00 0000 0000
} 0x7ffd7704573f = 00 0000 0000
▪ Uma matriz unidimensional é uma lista de células de
memória adjacentes
– Equação para referenciar um elemento de vetores iniciados em zero
vet[k] ↔ 'py' &vet[0] + k*sizeof(tipo)

– Equação para referenciar um elemento de vetores iniciados em um
vet[k] ↔ 'py' &vet[1] + (k-1)*sizeof(tipo)

– Equação para referenciar um elemento de vetores com faixas
quaisquer
vet[k] ↔ 'py' &vet[inicio] + (k-inicio)*sizeof(tipo)

▪ Uma matriz multidimensional também é uma lista de células
de memória adjacentes
Vetor Matriz Multidimensional
Tipos de Elemento Tipos de Elemento
Tipo de Índice Tipo de Índice
Limite Inferior do Índice Número de Dimensões
Limite Superior do Índice Faixa de Índice 1
Endereço …
Faixa de Índice N
Endereço
Ordenação
OrdenaçãoLinha-Coluna
Linha-Coluna ou
ou Row-Major
Row-MajorOrder
Order
Número de colunas
M[i][j] ↔ 'py' &M[0][0] + (i*nC + j)*sizeof(tipo)

Ordenação
OrdenaçãoColuna-Linha
Coluna-Linha ou
ou Column-Major
Column-MajorOrder
Order
Número de linhas
M[i][j] ↔ 'py' &M[0][0] + (j*nL + i)*sizeof(tipo)

▪ E se o índice estiver fora da faixa de valores permitido?
– Linguagens fortemente tipadas mantém o descritor do vetor em
tempo de execução para fazer essas verificações
int []a = new int[n];

a[k] ↔ 'py' k >= 0 && k < a.length
– Realizar o teste sempre antes de realizar qualquer acesso dá um

certo overhead no acesso ao vetor
“Eu não gasto meu tempo com essas coisas não.”
Overflow
Overflowde
debuffer
buffer→
→transbordamento
transbordamentode
deindexação
indexaçãoem
emmatrizes
matrizes

LIP20 - Matrizes

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

LIP20 - Matrizes

Enviado por

Direitos autorais:

Formatos disponíveis

20

double notas[30]; Matriz

Inicia de zero Inicia de um

▪ int, float, double… → zero

int lista[] = {4, 5, 7, 83};

char nome[] = "Programação";

char *nomes[] = { String[] nomes = {

LISTA: array (1..5) of INTEGER := (1, 3, 5, 7, 9);

lista = [x*x for x in range(0,10) if x % 3 == 0]

lista = [x*x | x <- [0..10], mod x 3 == 0]

MAT(2, 1:3, 1:4)

MAT(1:3, 1:3, 1:4)

MAT(1:3, 1:3, 2:3)

MAT(1:3, 1:3, 1:4)

LISTA: array (1..5) of INTEGER := (10, 3, 42, 18, 50);

B = [42, 3.14, 'ola', 'R2D2']

▪ Matriz heap-dinâmica Dados Estáticos

Tamanho do Vetor (fixo ou variável)

void f(int n){

Categoria Tamanho Tempo de Definição Alocação Local de Alocação

Categoria Tamanho Tempo de Definição Alocação Local de Alocação

Categoria Tamanho Tempo de Definição Alocação Local de Alocação

Categoria Tamanho Tempo de Definição Alocação Local de Alocação

▪ E o que acontece nessa atribuição?

vet[i] = 10; “O endereço de vet[i] recebe o valor 10”

Tipo do elemento da matriz

Tamanho do elemento da matriz

Faixa ou tamanho dos índices de cada dimensão

int A[10]; A: array(-4..5) of INTEGER;

vet[k] ↔ 'py' &vet[0] + k*sizeof(tipo)

vet[k] ↔ 'py' &vet[1] + (k-1)*sizeof(tipo)

vet[k] ↔ 'py' &vet[inicio] + (k-inicio)*sizeof(tipo)

Tipo de Índice Tipo de Índice

Limite Inferior do Índice Número de Dimensões

Limite Superior do Índice Faixa de Índice 1

M[i][j] ↔ 'py' &M[0][0] + (i*nC + j)*sizeof(tipo)

M[i][j] ↔ 'py' &M[0][0] + (j*nL + i)*sizeof(tipo)

int []a = new int[n];

– Realizar o teste sempre antes de realizar qualquer acesso dá um

“Eu não gasto meu tempo com essas coisas não.”

Você também pode gostar

M[i][j] ↔ 'py' &M[0][0] + (inC + j)sizeof(tipo)

M[i][j] ↔ 'py' &M[0][0] + (jnL + i)sizeof(tipo)