Arrays et matrices.

Une array est un tableau à n dimensions de valeurs de même type. Une matrice est une array à 2 dimensions.

Les matrices sont données par colonne (i.e. numéro de ligne = premier numéro varie en premier) :
si mat vaut

1   3
2   4

as.vector(mat) donne 1 2 3 4

Une matrice peut se définir en donnant ses éléments par colonne et en précisant l'une de ses dimensions :

• mat <- matrix(data = c(1, 2, 3, 4, 5, 6), nrow = 2)
• mat <- matrix(data = c(1, 2, 3, 4, 5, 6), ncol = 3)

as.vector(mat) redonne alors c(1, 2, 3, 4, 5, 6)

On peut donner les noms des lignes et des colonnes respectivement par :
mat <- matrix(c(3, 2, 1, 5, 6, 4), nrow = 3, dimnames = list(c("A", "B", "C"), c("a", "b")))

nrow(mat) et ncol(mat) : pour avoir le nombre de lignes et le nombre de colonnes d'une matrice.

t(mat) : transposée d'une matrice.

Indexation :

• mat[c(2, 3), ] : renvoie une sous-matrice de mat avec uniquement les lignes 2 et 3.
• mat[, seq(5, ncol(mat))] : renvoie une sous-matrice avec toutes les colonnes à partir de la colonne 5.
• mat[3, ] ou mat[c(3), ] : Attention, renvoie un vecteur correspondant à la ligne 3 de la matrice (quand matrice résultante a une seule dimension, on récupère un vecteur) ! Pour éviter cela et récupérer une matrice dans tous les cas : mat[3, , drop = FALSE]
• mat[1, 2] : renvoie un seul élément, celui sur la première ligne et deuxième colonne.
• mat[1, 2] <- 5 : change la valeur d'un élément.
• mat[1, ] <- c(5, 6, 7) : change la première ligne par la valeur du vecteur donné, supposant que la matrice a 3 colonnes. Si la matrice a simplement un nombre de colonnes multiple de 3, la première ligne sera une répétition successives des 3 valeurs (règle du recyclage) !

row(mat) : renvoie une matrice de même dimension que mat et dont chaque cellule a pour valeur son numéro de ligne. Idem avec col(mat) pour le numéro de colonne.

Diagonales et matrices : diag est une fonction dont les effets dépendent de ce qu'on lui donne en entrée :

• diag(mat) : renvoie un vecteur correspondant à la diagonale de la matrice mat.
• diag(vect) : renvoie une matrice diagonale dont les éléments sont ceux du vecteur vect.
• diag(k) (k étant un scalaire) : renvoie une matrice identité carrée de dimension k.
• diag(k, n) : renvoie une matrice diagonale carrée de dimension n et dont les éléments diagonaux sont égaux à k.
• diag(mat) <- vect : remplace la diagonale de mat par les éléments du vecteur vect.

Une matrice peut avoir des noms de lignes et de colonnes

• mat <- matrix(data = c(1, 2, 3, 4), nrow = 2, ncol = 2, dimnames = list(c("a", "b"), c("A", "B"))) : pour définir les noms des lignes et des colonnes (lignes d'abord et colonnes ensuite).
• rownames(mat), colnames(mat) : renvoient les noms des lignes et des colonnes (ici c("a", "b") et c("A", "B") respectivement).
• On peut faire directement une affectation : rownames(mat) <- c("aa", "bb").

rbind et cbind :

• cbind(vect1, vect2, vect2) : renvoie une matrice dont les vecteurs colonnes sont les vecteurs vect1, vect2, vect3.
• rbind(vect1, vect2, vect2) : idem, mais avec les vecteurs lignes.
• Usage répété de cbind et rbind n'est pas efficace : mieux vaut créer directement une matrice de la taille finale et la remplir.

Opérations sur les matrices. Si mat1 et mat2 sont des matrices :

• mat1 + mat2 : addition de matrices.
• mat1 * mat2 : multiplication de matrices terme à terme : ce n'est pas la multiplication de matrices au sens mathématique !
• mat1 %*% mat2 : la vraie multiplication (produit) de matrices au sens mathématique.
• mat1 %*% mat2 : la vraie multiplication de matrices au sens mathématique.
• mat1 %*% vect : multiplication d'une matrice par un vecteur au sens mathématique (si tailles compatibles).
• mat1 * vect : si vect de longeur total égale au nombre d'élements de la matrice, multiplie chaque élément de la matrice par un élément du vecteur, si vect a la longueur d'une colonne, multiplie chaque chaque colonne de la matrice par vect.
• vect %*% mat %*% vect : si la matrice mat et le vecteur vect ont des tailles compatibles, multiplication en effectuant automatiquement là où c'est nécessaire la transposition.

Outer product : array1 %o% array2 : array de dimension c(dim(array1), dim(array2)) obtenue par toutes les combinaisons de multiplication possibles (opération non commutative) :

• Cas le plus simple : 2 vecteurs. c(4, 6, 2) %o% c(3, 2) donne la matrice :

       [,1] [,2]
  [1,]   12    8
  [2,]   18   12
  [3,]    6    4
    

• outer(array1, array2, "*") : autre formulation possible de array1 %o% array2, sauf qu'elle peut être généralisée à d'autres opérateurs (par exemple, outer(array1, array2, "+"))
• x <- seq(3); y <- seq(5); outer(x, y, function(x, y) x ^ 2 + y ^ 2) : renvoie une évaluation de la fonction sur toutes les valeurs de la grille d'entiers [1,3] x [1,5].

Agrégats sur les matrices :

• rowSums(mat) et colSums(mat) : renvoient les vecteurs contenant la somme des lignes ou la somme des colonnes.
• rowMeans(mat) et colMeans(mat) : renvoient les vecteurs contenant la moyenne des lignes ou la moyenne des colonnes.
• avec rowSums, colSums, rowMeans, colMeans, utiliser na.rm = TRUE pour éviter de tenir compte des valeurs NA (sinon, le résultat est NA si il y a un seul NA sur la ligne ou la colonne).

apply : c'est une généralisation de rowSums. Le second argument est le vecteur des dimensions qui restent après avoir appliqué la fonction :

• apply(mat, 1, sum) : renvoie un vecteur avec la somme des lignes.
• apply(mat, 2, sum) : renvoie un vecteur avec la somme des colonnes.
• apply(mat, 1, mean) : renvoie un vecteur avec la moyenne des lignes.
• apply(array, c(1, 2), sum) où array est une array à 3 dimensions : renvoie une matrice où chaque élément est la somme des éléments sur la 3ème dimension.
• apply(mat, c(1,2), function(x) {ifelse(x != 0, 1, 0)}) : renvoie une matrice de même dimension dont les éléments sont 1 ou 0 selon que la valeur de départ est non nulle ou nulle.
• apply(mat, 1, mean, trim = 0.1) : les arguments après la fonction sont les arguments supplémentaires à passer à celle-ci.

Conversion d'une matrice de type character en matrice numérique :

mat <- matrix(c("7", "5", "6", "2"), nrow = 2)
mat <- apply(mat, c(1, 2), as.numeric)

sweep sur une matrice numérique :

• sweep(mat, 1, rowMeans(mat)) : enlève à chaque valeur la moyenne de chaque ligne.
• sweep(mat, 2, colMeans(mat)) : enlève à chaque valeur la moyenne de chaque colonne.
• sweep(mat, 1, rowMeans(mat), FUN = "/") : divise chaque valeur par la moyenne par ligne.

scale sur une matrice numérique : vise à normaliser les données, chaque colonne représentant une variable et chaque ligne un individu :

• scale(mat, center = TRUE, scale = FALSE) : soustrait de chaque valeur la moyenne par colonne (i.e. colonnes ont alors une moyenne nulle). Identique à sweep(mat, 2, colMeans(mat)).
• scale(mat, center = TRUE, scale = TRUE), ou même scale(mat) : normalise pour que chaque colonne soit de moyenne 0 et d'écart-type 1.

Définition d'une array par ses données et ses dimensions :
arr <- array(data = c(1, 2, 3, 4, 5, 6, 7, 8), dim = c(2, 2, 2)) donne un tableau de dimensions 2 x 2 x 2 (ligne x colonne x 3ème dimension). as.vector(arr) redonne le vecteur de départ.

Si a est une array de dimension 2 x 4 x 3, alors dim(a) vaut c(2, 4, 3). Alors :

• a[1,2:3,1:3] : sous array de dimension c(2, 3) (donc une matrice)
• a[1,,] : sous array de dimensions 4 x 3 (indice vide = tous les indices)
• a[,,] est équivalent à a.

Permutation des dimensions d'une array : échange les dimensions de l'array avec la permutation donnée :

• si dim(array) vaut c(2, 3, 4), aperm(array, c(3, 2, 1)) aura pour dimension c(4, 3, 2).
• aperm(mat, c(2, 1)) pour une matrice mat est simplement la transposée.

Indexation de matrice par une autre matrice : si mat est une matrice 4 x 3 et matInd est une matrice 2 x 2 dont les valeurs sont entières et dans [1,4] x [1,3], mat[matInd] est un vecteur de valeurs de mat dont les coordonnées sont les vecteurs lignes de matInd :

> mat
     [,1] [,2] [,3]
[1,]    1    5    9
[2,]    2    6   10
[3,]    3    7   11
[4,]    4    8   12
> matInd
     [,1] [,2]
[1,]    4    3
[2,]    2    1
> mat[matInd]
[1] 12  2

Résolution d'équations linéaires et inversion de matrice :

• solve(mat) : calcule l'inverse d'une matrice carrée mat.
• solve(mat, vect) : résoud l'équation linéaire mat %*% x = vect (attention, ne pas la résoudre en faisant solve(mat) %*% vect, car c'est inefficace et cela peut être instable).

Calcul du déterminant d'une matrice carrée :
det(mat) : renvoie un scalaire.

Calcul de valeurs propres et vecteurs propres d'une matrice carrée (diagonalisation de matrices) :
Pour une matrice carrée mat :

• vp <- eigen(mat) : calcule les valeurs propres et les vecteurs propres et renvoie une liste.
• vp$values : le vecteur des valeurs propres de dimension n si mat est une matrice n x n.
• vp$vectors : la matrice des vecteurs propres. Chaque colonne vp$vectors[, j] est un vecteur propre de valeur propre vp$values[j].

---