MATLAB: Dominando Arrays Multidimensionais e Especiais

No MATLAB, todas as variáveis de todos os tipos de dados são arrays multidimensionais. Um vetor é um array unidimensional e uma matriz é um array bidimensional.

Já discutimos vetores e matrizes. Neste capítulo, abordaremos arrays multidimensionais. Antes disso, porém, vamos explorar alguns tipos especiais de arrays.

Arrays Especiais no MATLAB

Esta seção apresenta funções que criam arrays especiais. Para todas essas funções, um único argumento cria um array quadrado; dois argumentos criam um array retangular.

A função zeros()

Cria um array preenchido com zeros.

Exemplo:

zeros(5)

Resultado:

ans =
     0     0     0     0     0
     0     0     0     0     0
     0     0     0     0     0
     0     0     0     0     0
     0     0     0     0     0

A função ones()

Cria um array preenchido com uns.

Exemplo:

ones(4,3)

Resultado:

ans =
     1     1     1
     1     1     1
     1     1     1
     1     1     1

A função eye()

Cria uma matriz identidade.

Exemplo:

eye(4)

Resultado:

ans =
     1     0     0     0
     0     1     0     0
     0     0     1     0
     0     0     0     1

A função rand()

Cria um array com números aleatórios uniformemente distribuídos no intervalo (0,1).

Exemplo:

rand(3, 5)

Resultado (valores variam a cada execução):

ans =
    0.8147    0.9134    0.2785    0.9649    0.9572
    0.9058    0.6324    0.5469    0.1576    0.4854
    0.1270    0.0975    0.9575    0.9706    0.8003

Quadrado Mágico

Um quadrado mágico é uma matriz quadrada onde a soma dos elementos é a mesma em todas as linhas, colunas e diagonais principais.

A função magic() cria um quadrado mágico. Recebe um único argumento escalar (tamanho do quadrado), que deve ser maior ou igual a 3.

Exemplo:

magic(4)

Resultado:

ans =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

Arrays Multidimensionais

Um array com mais de duas dimensões é chamado de array multidimensional no MATLAB. Eles são uma extensão natural das matrizes bidimensionais.

Geralmente, cria-se primeiro um array bidimensional e depois o estende.

Exemplo: Crie um array 3x3 a:

a = [7 9 5; 6 1 9; 4 3 2]

Resultado:

a =
     7     9     5
     6     1     9
     4     3     2

Adicione uma terceira dimensão:

a(:, :, 2) = [1 2 3; 4 5 6; 7 8 9]

Resultado:

a(:,:,1) =
     7     9     5
     6     1     9
     4     3     2
a(:,:,2) =
     1     2     3
     4     5     6
     7     8     9

Também é possível criar arrays multidimensionais diretamente com ones(), zeros() ou rand().

Exemplo:

b = rand(4,3,2)

Cria um array 4x3x2 com valores aleatórios.

A função cat()

Concatena uma lista de arrays ao longo de uma dimensão especificada.

Sintaxe:

B = cat(dim, A1, A2, ...)

• B – novo array criado
• A1, A2, ... – arrays a concatenar
• dim – dimensão ao longo da qual concatenar

Exemplo:

a = [9 8 7; 6 5 4; 3 2 1];
b = [1 2 3; 4 5 6; 7 8 9];
c = cat(3, a, b, [2 3 1; 4 7 8; 3 9 0])

Resultado:

c(:,:,1) =
     9     8     7
     6     5     4
     3     2     1
c(:,:,2) =
     1     2     3
     4     5     6
     7     8     9
c(:,:,3) =
     2     3     1
     4     7     8
     3     9     0

Funções de Array

O MATLAB fornece funções para ordenar, rotacionar, permutar, remodelar ou deslocar conteúdo de arrays.

Função	Finalidade
length	Comprimento do vetor ou maior dimensão do array
ndims	Número de dimensões do array
numel	Número de elementos do array
size	Dimensões do array
iscolumn	Verifica se a entrada é vetor coluna
isempty	Verifica se o array está vazio
ismatrix	Verifica se a entrada é matriz
isrow	Verifica se a entrada é vetor linha
isscalar	Verifica se a entrada é escalar
isvector	Verifica se a entrada é vetor
blkdiag	Constrói matriz diagonal em blocos
circshift	Desloca array circularmente
ctranspose	Transposta conjugada complexa
diag	Matrizes diagonais e diagonais de matriz
flipdim	Inverte array ao longo de dimensão especificada
fliplr	Inverte matriz da esquerda para direita
flipud	Inverte matriz de cima para baixo
ipermute	Inverte permutação de dimensões de array N-D
permute	Reorganiza dimensões de array N-D
repmat	Replica e ladrilha array
reshape	Remodela array
rot90	Rotaciona matriz 90 graus
shiftdim	Desloca dimensões
issorted	Verifica se elementos estão ordenados
sort	Ordena elementos do array
sortrows	Ordena linhas
squeeze	Remove dimensões singleton
transpose	Transposta
vectorize	Vetoriza expressão

Exemplos

Comprimento, Dimensões e Número de Elementos

x = [7.1, 3.4, 7.2, 28/4, 3.6, 17, 9.4, 8.9];
length(x)  % comprimento do vetor x
y = rand(3, 4, 5, 2);
ndims(y)   % número de dimensões do array y
s = ['Zara', 'Nuha', 'Shamim', 'Riz', 'Shadab'];
numel(s)   % número de elementos em s

Resultado:

ans = 8
ans = 4
ans = 23

Deslocamento Circular de Elementos

a = [1 2 3; 4 5 6; 7 8 9];
b = circshift(a,1);        % desloca primeira dimensão para baixo por 1
c = circshift(a,[1 -1]);   % desloca primeira dim. para baixo 1 e segunda para esquerda 1

Resultado:

a =
     1     2     3
     4     5     6
     7     8     9
b =
     7     8     9
     1     2     3
     4     5     6
c =
     8     9     7
     2     3     1
     5     6     4

Ordenação de Arrays

v = [23 45 12 9 5 0 19 17];
sort(v)                 % ordena vetor
m = [2 6 4; 5 3 9; 2 0 1];
sort(m, 1)              % ordena ao longo das linhas (colunas)
sort(m, 2)              % ordena ao longo das colunas (linhas)

Resultado:

v = 23 45 12 9 5 0 19 17
ans = 0 5 9 12 17 19 23 45
m = 2 6 4; 5 3 9; 2 0 1
ans = 2 0 1; 2 3 4; 5 6 9
ans = 2 4 6; 3 5 9; 0 1 2

Cell Arrays (Arrays de Células)

Cell arrays são arrays indexados onde cada célula pode armazenar arrays de diferentes dimensões e tipos de dados.

A função cell cria um cell array.

C = cell(dim)
C = cell(dim1,...,dimN)
D = cell(obj)

• C – cell array
• dim – escalar ou vetor de inteiros especificando dimensões
• dim1,...,dimN – inteiros escalares para cada dimensão
• obj – array ou objeto Java, ou array .NET System.String/Object

Exemplo

c = cell(2, 5);
c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5}

Resultado:

c =
  2×5 cell array
    {'Red'    }    {'Blue'   }    {'Green' }    {'Yellow'}    {'White'}
    {[   1]}    {[   2]}    {[   3]}    {[   4]}    {[   5]}

Acessando Dados em Cell Arrays

Duas formas de referenciar elementos:

• Parênteses () – referenciam conjuntos de células
• Chaves {} – referenciam o conteúdo dentro de células individuais

Exemplo com parênteses:

c = {'Red', 'Blue', 'Green', 'Yellow', 'White'; 1 2 3 4 5};
c(1:2,1:2)

Resultado:

ans =
  2×2 cell array
    {'Red' }    {'Blue'}
    {[ 1]}    {[ 2]}

Exemplo com chaves:

c{1, 2:4}

Resultado:

ans = 'Blue'
ans = 'Green'
ans = 'Yellow'