Arrays em R

Um array é uma estrutura de dados que pode armazenar dados multidimensionais. Em R, arrays são objetos que podem guardar dados em duas ou mais dimensões. Por exemplo, matrizes quadradas podem conter duas linhas e duas colunas e a dimensão pode chegar a cinco. Arrays armazenam valores de um mesmo tipo de dado. Os dados podem ter mais de uma dimensão, com linhas, colunas e profundidade.

Criação de um array

A função array() cria um array a partir de um vetor (números) e das dimensões ("dim") passadas como argumento.

Veja o exemplo abaixo, em que dois vetores chamados 'array1' e 'array2' são criados.

vector1 =  c (5, 10, 15,20)
vector2 =  c (25, 30, 35, 40, 45, 50,55,60)

Você pode usar os dois vetores acima como entrada de um array com dimensão 4 * 4, criando duas matrizes (dados dimensionais).

final = array (c (array1, array2),dim =c(4,4,3))
print (final)

A saída do código acima é a seguinte:

, , 1

     [,1] [,2] [,3] [,4]
[1,]    5   25   45    5
[2,]   10   30   50   10
[3,]   15   35   55   15
[4,]   20   40   60   20

, , 2

     [,1] [,2] [,3] [,4]
[1,]   25   45    5   25
[2,]   30   50   10   30
[3,]   35   55   15   35
[4,]   40   60   20   40

, , 3

     [,1] [,2] [,3] [,4]
[1,]   45    5   25   45
[2,]   50   10   30   50
[3,]   55   15   35   55
[4,]   60   20   40   60

Vamos renomear nosso array para "Arr1" e "Arr2" usando "matrix.names". Além disso, os nomes das linhas serão ("row1","row2") e os nomes das colunas serão ("column1","column2","column3"), respectivamente. A dimensão da matriz é 2 linhas por 3 colunas.

array1 =  c (9 , 18 )
array2 = c (27,36)
r.names = c ("column1","column2","column3")
c.names = c ("row1","row2")
m.names = c ("Arr1", "Arr2")

final = array (c (array1,array2), dim=c (2,3,2), dimnames=list (c.names, r.names, m.names))
print(final)

A saída do código acima aparece abaixo, com duas linhas e três colunas. Note também que os valores nas colunas se repetem quando chegam ao fim:

, , Arr1

     column1 column2 column3
row1       9      27       9
row2      18      36      18

, , Arr2

     column1 column2 column3
row1      27       9      27
row2      36      18      36

Indexação em um array

Um array é composto por elementos em várias dimensões, e cada elemento pode ser acessado para operações. Os elementos podem ser indexados usando '[]'. Em arrays do tipo matriz, com linhas e colunas, a indexação é feita por: mat[linha, coluna]

Veja o exemplo a seguir, em que o array contém a entrada vetorial de 1 a 9. Há três linhas e três colunas, com valores de 1 a 9. O 'c.names)' define os novos nomes de coluna com os vetores ('c1', 'c2', 'c3') e 'r.names' define os novos nomes de linha ('r1', 'r2', 'r3').

a1=  c (1,2,3,4)
a2= c (5,6,7,8,9)
r.names = c ("c1","c2","c3")
c.names = c ("r1","r2","r3")
m.names = c ("first")

arr = array (c (a1,a2), dim=c (3,3,1), dimnames=list (c.names, r.names, m.names))
print(arr)

, , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9

A saída do código acima é:

 , , first

   c1 c2 c3
r1  1  4  7
r2  2  5  8
r3  3  6  9 

Perceba que as matrizes de 1 a 9 foram geradas em formato 3 x 3 (linhas x colunas), e os nomes de linhas e colunas foram alterados.

Vamos ver como extrair elementos do array com os exemplos a seguir.

1. Vamos extrair o número '7' do array 'arr' acima.

arr[1,3,1]

7

A saída do código acima é 7. Em 'arr[1,3,1]', pegamos a linha 1, coluna 3, na primeira "camada" do array 'arr'.

1. Para acessar o 1, use 'arr[1,1,1]': linha 1, coluna 1, na primeira camada do array.

arr[1,1,1]

1

A saída do código acima é 1.

1. Para acessar múltiplos valores de uma vez, especifique o intervalo desejado.

arr[1:2,1:2,1]

O código acima retorna o seguinte, extraindo 2 linhas, 2 colunas, na primeira camada do array 'arr':

    c1    c2
r1    1    4
r2    2    5 

1. Você pode acessar toda a matriz 'arr' com a sintaxe 'arr[ , ,1]', que indica incluir todas as linhas e colunas (separadas por vírgulas). O 1 indica a primeira camada do array a ser extraída.

arr[ , ,1]

O código acima retorna o seguinte, com todos os elementos presentes:

    c1    c2    c3
r1    1    4    7
r2    2    5    8
r3    3    6    9 

1. Você pode obter a segunda linha inteira com 'arr[2,,1]': seleciona a segunda linha (espaço indica todas as colunas) na primeira camada do array.

arr[2,,1]

c1

2

c2

5

c3

8

O código acima gera a seguinte saída e também imprime c1, c2, c3.

c1 2
c2 5
c3 8

1. Você pode obter a segunda coluna inteira com 'arr[,2,1]': o espaço indica todas as linhas, 2 é a segunda coluna, e 1 é a primeira camada do array.

mat[ ,2,1]

r1

4

r2

5

r3

6

O código acima gera a seguinte saída e também imprime r1, r2, r3.

r1 4
r2 5
r3 6

Criação e soma de matrizes

Vamos criar duas matrizes chamadas mat1 e mat2 a partir de 'arr[ , ,1]', copiando todas as linhas e colunas de 'arr'.

mat1 = arr[,,1]
mat2 = arr[,,1]

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

Some as matrizes 'mat1' e 'mat2' e guarde o resultado em final. A saída também é impressa.

final <- mat1+mat2
print(final)

A saída abaixo mostra que cada linha e coluna de mat1 e mat2 foram somadas elemento a elemento.

   c1 c2 c3
r1  2  8 14
r2  4 10 16
r3  6 12 18 

apply()

'apply()' faz parte dos pacotes de R e inclui várias funções que ajudam a escrever código de forma mais simples e eficiente. No exemplo abaixo, ela é usada para calcular somas em dois arrays.

A sintaxe de apply() é:
apply(x, margin, function)

Os argumentos indicam:
x: um array ou dados bidimensionais (matrizes).
margin: indica onde aplicar a função: c(1) para linhas, c(2) para colunas, e c(1,2) para linhas e colunas.
function: função interna do R ou definida pelo usuário a ser aplicada aos dados.

Vamos criar um vetor 'array1' de tamanho três e 'array2' de tamanho seis com o código a seguir.

array1 = c(5,10,15)
array2 = c(15,20,25,30,35,40)

Veja abaixo como 'array()' recebe os vetores 'array1' e 'array2' com dimensão de 3 linhas, 3 colunas e cria 2 matrizes armazenadas em 'my.Array'.

my.Array <- array(c(array1,array2),dim = c(3,3,2))
print(my.Array)

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

O código acima gera a seguinte saída, em que duas matrizes 3 x 3 (linhas x colunas) são criadas.

, , 1

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

, , 2

     [,1] [,2] [,3]
[1,]    5   15   30
[2,]   10   20   35
[3,]   15   25   40

Em seguida, 'apply()' é usada para calcular a soma das duas matrizes por coluna.

final <- apply(my.Array, c(2), sum)
print(final)

[1]  60 120 210

Note acima o uso de c(2) para a margem: os elementos de 'my.Array' são somados por coluna para obter a saída a seguir.

60 120 210

Por fim, 'apply()' é usada para calcular a soma das duas matrizes por linha.

final <- apply(my.Array, c(1), sum)
print(final)

[1] 100 130 160

Note acima o uso de c(1) para a margem: os elementos de 'my.Array' são somados por linha para obter a saída a seguir.

100 130 160

Parabéns

Parabéns, você chegou ao fim deste tutorial!

Você aprendeu sobre arrays em R, como criá-los e indexá-los com exemplos, além de criar e somar matrizes e usar a função apply().

Se quiser aprender mais sobre R, faça o curso Introduction to R da DataCamp.

Referências:
R-Arrays
R Array Function and Create Array in R