Tableaux en R

Un tableau (array) est une structure de données capable de stocker des données multidimensionnelles. En R, un tableau est un objet qui peut contenir des données à deux dimensions ou plus. Par exemple, des matrices carrées peuvent avoir deux lignes et deux colonnes, et la dimension peut aller jusqu’à cinq. Les tableaux ne stockent que des valeurs d'un même type de données. Les données peuvent être multidimensionnelles, avec des lignes, des colonnes et des dimensions de longueurs données.

Création d’un tableau

La fonction array() crée un tableau à partir d’un vecteur (des nombres) et d’un argument de dimension ("dim").

Voyons un exemple ci-dessous où deux vecteurs nommés "array1" et "array2" sont créés.

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

Vous pouvez utiliser les deux vecteurs ci-dessus comme entrée d’un tableau avec une dimension 4 * 4 ; deux matrices (données bidimensionnelles) sont alors créées.

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

La sortie du code ci-dessus est la suivante :

, , 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

Renommons maintenant notre tableau en "Arr1" et "Arr2" en utilisant "matrix.names". De plus, les noms de lignes deviennent ("row1","row2") et les noms de colonnes ("column1","column2","column3"). La matrice a 2 lignes et 3 colonnes.

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)

Voici la sortie du code ci-dessus : il y a deux lignes et trois colonnes. Notez aussi que les valeurs d’une colonne se répètent une fois épuisées :

, , Arr1

     column1 column2 column3
row1       9      27       9
row2      18      36      18

, , Arr2

     column1 column2 column3
row1      27       9      27
row2      36      18      36

Indexer un tableau

Un tableau contient des éléments organisés de manière multidimensionnelle, et chaque élément peut être accédé pour effectuer des opérations. Les éléments se récupèrent avec les crochets '[]'. Pour un tableau de type matrice avec lignes et colonnes, l’indexation se fait ainsi : mat[row, column]

Prenons l’exemple ci-dessous : le tableau contient les valeurs de 1 à 9. Il y a trois lignes et trois colonnes, couvrant les valeurs de 1 à 9. 'c.names' définit les nouveaux noms de colonnes via le vecteur ('c1', 'c2', 'c3') et 'r.names' les nouveaux noms de lignes ('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

La sortie du code ci-dessus est :

 , , first

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

Vous voyez que les valeurs de 1 à 9 sont disposées en matrice 3 × 3 (lignes × colonnes), avec des noms de lignes et de colonnes personnalisés.

Voyons maintenant comment extraire des éléments du tableau avec les exemples suivants.

1. Extrayons le nombre "7" du tableau 'arr' ci-dessus.

arr[1,3,1]

7

La sortie est 7. Dans 'arr[1,3,1]', on sélectionne la ligne 1, la colonne 3, et le 1 indique la première tranche du tableau 'arr'.

1. Pour accéder à 1, utilisez 'arr[1,1,1]' : ligne 1, colonne 1, dans la première tranche de 'arr'.

arr[1,1,1]

1

La sortie du code ci-dessus est 1.

1. Pour accéder à plusieurs valeurs à la fois, indiquez l’intervalle souhaité.

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

Le code ci-dessus produit la sortie suivante : on extrait 2 lignes, 2 colonnes de la première tranche de 'arr'.

    c1    c2
r1    1    4
r2    2    5 

1. Vous pouvez récupérer la tranche entière avec la syntaxe suivante : 'arr[ , ,1]' indique que l’on prend toutes les lignes et toutes les colonnes (espaces laissés vides), et 1 précise la tranche à extraire.

arr[ , ,1]

Le code ci-dessus affiche tous les éléments :

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

1. Vous pouvez récupérer toute la deuxième ligne avec le code suivant : arr[2, ,1] sélectionne la deuxième ligne (espace pour les colonnes), et 1 est la tranche à extraire.

arr[2,,1]

c1

2

c2

5

c3

8

La sortie ci-dessous affiche également c1, c2, c3.

c1 2
c2 5
c3 8

1. Vous pouvez récupérer toute la deuxième colonne avec le code suivant : arr[,2,1] (espace pour les lignes, 2 pour la colonne), et 1 est la tranche à extraire.

mat[ ,2,1]

r1

4

r2

5

r3

6

La sortie ci-dessous affiche également r1, r2, r3.

r1 4
r2 5
r3 6

Création et addition de matrices

Créons deux matrices nommées mat1 et mat2 à partir de 'arr[ , ,1]' : toutes les lignes et colonnes de 'arr' sont copiées.

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

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

Additionnez les deux matrices 'mat1' et 'mat2' et stockez le résultat dans final. On affiche également la sortie.

final <- mat1+mat2
print(final)

La sortie ci-dessous montre que les éléments de mat1 et mat2 sont additionnés élément par élément.

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

apply()

'apply()' fait partie des packages R et regroupe plusieurs fonctions qui facilitent et optimisent l’écriture de code. Voyez ci-dessous un exemple d’utilisation pour calculer des sommes sur deux tableaux.

La syntaxe de apply() est :
apply(x, margin, function)

Les arguments signifient :
x : un tableau (array) ou des données bidimensionnelles (matrices).
margin : la marge d’application de la fonction : c(1) pour les lignes, c(2) pour les colonnes, c(1,2) pour lignes et colonnes.
function : la fonction R (native ou définie par l’utilisateur) à appliquer aux données.

Créons un vecteur 'array1' de longueur trois et 'array2' de longueur six avec le code suivant.

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

Ci-dessous, 'array()' accepte deux vecteurs 'array1' et 'array2' pour créer un objet de dimension 3 lignes, 3 colonnes et 2 matrices, stocké dans '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

Le code ci-dessus produit la sortie suivante : deux matrices de dimension 3 × 3 (lignes × colonnes) sont créées.

, , 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

Nous utilisons 'apply()' ci-dessous pour calculer la somme des deux matrices par colonnes.

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

[1]  60 120 210

Ici, la marge c(2) indique une agrégation par colonnes : les éléments de 'my.Array' sont additionnés colonne par colonne pour obtenir la sortie ci-dessous.

60 120 210

Enfin, 'apply()' est utilisé ci-dessous pour calculer la somme par lignes.

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

[1] 100 130 160

Avec la marge c(1), les éléments de 'my.Array' sont additionnés ligne par ligne, pour donner la sortie suivante.

100 130 160

Félicitations

Félicitations, vous êtes arrivé au bout de ce tutoriel !

Vous avez découvert les tableaux en R, leur création et leur indexation, ainsi que la création et l’addition de matrices et l’utilisation de la fonction apply().

Pour aller plus loin avec R, suivez le cours Introduction to R de DataCamp.

Références :
R-Arrays
R Array Function and Create Array in R