Fonction matricielle dans R : créer, imprimer, ajouter une colonne et une tranche

Fonction matricielle dans R

Une fonction matricielle dans R est un tableau à 2 dimensions comportant m nombre de lignes et n nombre de colonnes. En d’autres termes, la matrice dans la programmation R est une combinaison de deux ou plusieurs vecteurs avec le même type de données.

En réalité, une matrice est simplement un vecteur possédant un attribut `dim` de longueur deux. C'est pourquoi chaque élément doit être de même type : dès qu'une valeur de type caractère est associée à des nombres, la matrice entière est convertie en caractère. R stocke les valeurs colonne par colonne et utilise `dim` pour déterminer la fin de chaque ligne. Type de données s'applique à l'objet entier en une seule fois.

À noter: La fonction `matrix()` renvoie toujours deux dimensions. Pour créer une structure à trois dimensions ou plus en R, utilisez `array()` avec un vecteur de dimensions, ou assignez directement `dim()`. Le diagramme ci-dessous illustre la disposition en lignes et en colonnes de toute matrice.

Comment créer une matrice dans R

Nous pouvons créer une matrice avec la fonction matrice()La signature de base de R prend cinq arguments, et les trois plus fréquemment utilisés sont présentés ici :

matrix(data, nrow, ncol, byrow = FALSE)

Arguments:

• données,: L'ensemble des éléments que R va organiser en lignes et en colonnes de la matrice.
• maintenant: Nombre de lignes.
• ncol: Nombre de colonnes.
• parrow: Indicateur logique. Par défaut, avec byrow = FALSE, la matrice est remplie colonne par colonne, de haut en bas. Avec byrow = TRUE, elle est remplie ligne par ligne, de gauche à droite.
• noms de dimensions: Une liste facultative de longueur deux fournissant les noms de lignes et les noms de colonnes.

Deux points importants de la documentation de base de R sont à connaître avant le premier exemple. Si seul l'un des paramètres `nrow` ou `ncol` est fourni, R déduit l'autre à partir de la longueur des données. De plus, si les données contiennent trop peu d'éléments pour correspondre à la forme demandée, les valeurs sont réutilisées plutôt que rejetées.

Construisons deux matrices 5×2 à partir de la séquence de nombres de 1 à 10, l'une avec byrow = TRUE et l'autre avec byrow = FALSE, pour observer la différence.

# Construct a matrix with 5 rows that contain the numbers 1 up to 10 and byrow =  TRUE 
matrix_a <-matrix(1:10, byrow = TRUE, nrow = 5)
matrix_a

Sortie :

Comme byrow = TRUE a été utilisé, la console remplit la première ligne avec 1 et 2, la deuxième ligne avec 3 et 4, et ainsi de suite.

Afficher la dimension de la matrice_a avec dim()

Maintenant, imprimons la dimension de la matrice dans R avec dim(). La syntaxe pour imprimer la matrice dans R en utilisant dim() est :

# Print dimension of the matrix with dim()
dim(matrix_a)

Sortie :

## [1] 5 2

La fonction dim() renvoie d'abord le nombre de lignes, puis le nombre de colonnes, confirmant ainsi la forme 5×2.

Remplir une matrice par colonne avec byrow = FALSE

Les mêmes dix nombres et la même rangée produisent une disposition différente lorsque le sens de remplissage change.ping Par défaut, la fonction byrow envoie les valeurs de la première colonne avant le début de la seconde.

# Construct a matrix with 5 rows that contain the numbers 1 up to 10 and byrow =  FALSE
matrix_b <-matrix(1:10, byrow = FALSE, nrow = 5)
matrix_b

Sortie :

Afficher la dimension de la matrice_b avec dim()

Encore une fois, imprimez la dimension de la matrice en utilisant dim(). Vous trouverez ci-dessous une syntaxe de la dimension de la matrice d'impression R :

# Print dimension of the matrix with dim()
dim(matrix_b)

Sortie :

## [1] 5 2

La forme reste inchangée à 5×2, car byrow modifie l'ordre de remplissage et jamais les dimensions.

Note: L'utilisation de la commande matrix_b <-matrix(1:10, byrow = FALSE, ncol = 2) aura le même effet que ci-dessus, puisque R déduit nrow = 5 à partir des dix valeurs fournies.

Vous pouvez également créer une matrice 4×3 avec la fonction `ncol`. R créera 3 colonnes et les remplira de haut en bas. Consultez un exemple.

matrix_c <-matrix(1:12, byrow = FALSE, ncol = 3)
matrix_c

Sortie :

##       [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12

Les en-têtes de colonnes [,1] à [,3] et les étiquettes de lignes [1,] à [4,] sont des espaces réservés par défaut dans R. Ils disparaissent dès que des noms de dimensions réels sont fournis, comme indiqué plus loin dans ce tutoriel.

Exemple :

dim(matrix_c)

Sortie :

## [1] 4 3

Ajouter une colonne à une matrice avec cbind()

Vous pouvez ajouter une colonne à une matrice R avec la commande `cbind()`. `cbind()` signifie « liaison de colonnes » et permet de concaténer autant de matrices ou de colonnes que spécifié. Par exemple, notre exemple précédent a créé une matrice 5×2. Nous y ajoutons une troisième colonne et vérifions que la dimension est bien de 5×3.

Exemple :

# concatenate c(1:5) to the matrix_a
matrix_a1 <- cbind(matrix_a, c(1:5))
# Check the dimension
dim(matrix_a1)

Sortie :

## [1] 5 3

Exemple :

matrix_a1

Sortie

##       [,1] [,2] [,3]
## [1,]    1    2    1
## [2,]    3    4    2
## [3,]    5    6    3
## [4,]    7    8    4
## [5,]    9   10    5

Exemple :

Il est également possible de lier plusieurs colonnes simultanément. Le bloc suivant construit la matrice a2, une matrice 4×3 contenant les nombres de 13 à 24, afin de la joindre à la matrice c, également de taille 4×3, pour obtenir un résultat 4×6 couvrant les nombres de 1 à 24.

matrix_a2 <-matrix(13:24, byrow = FALSE, ncol = 3)

Sortie :

##      [,1] [,2] [,3]
## [1,]   13   17   21
## [2,]   14   18   22
## [3,]   15   19   23
## [4,]   16   20   24

Exemple :

matrix_c <-matrix(1:12, byrow = FALSE, ncol = 3)		
matrix_d <- cbind(matrix_a2, matrix_c)
dim(matrix_d)

Sortie :

## [1] 4 6

REMARQUEPour que la fonction `cbind()` fonctionne, le nombre de lignes des matrices dans R doit être identique. En cas de différence, R réutilise la matrice la plus courte ou génère une erreur ; il est donc plus sûr de vérifier dim() sur les deux objets au préalable.

Alors que `cbind()` concatène les colonnes, `rbind()` ajoute les lignes. Ajoutons une ligne à notre matrice `matrix_c` et vérifions que sa dimension est bien de 5×3.

matrix_c <-matrix(1:12, byrow = FALSE, ncol = 3)
# Create a vector of 3 columns
add_row <- c(1:3)
# Append to the matrix
matrix_c <- rbind(matrix_c, add_row)
# Check the dimension
dim(matrix_c)

Sortie :

## [1] 5 3

Notez que la liaison d'un vecteur nommé tel que add_row donne également ce nom à la nouvelle ligne, ce qui constitue la première étape vers les matrices étiquetées abordées plus loin.

Découper une matrice

Nous pouvons sélectionner un ou plusieurs éléments d'une matrice dans Programmation R en utilisant les crochets [ ]. À l'intérieur des crochets, le sélecteur de ligne précède le sélecteur de colonne, séparés par une virgule. C'est là que le découpage entre en jeu.

Par exemple :

• Matrix_c[1,2] sélectionne l'élément de la première ligne et de la deuxième colonne.
• matrix_c[1:3,2:3] donne un résultat de matrice R slice avec les données sur les lignes 1, 2, 3 et les colonnes 2 et 3.
• Matrix_c[,1] sélectionne tous les éléments de la première colonne.
• Matrix_c[1,] sélectionne tous les éléments de la première ligne.

Laisser un côté de la virgule vide signifie donc que toutes les valeurs de ce côté seront prises en compte. Une conséquence trompeuse pour les débutants : lorsqu’une seule ligne ou colonne est sélectionnée, R ignore la dimension vide et renvoie un vecteur simple. Ajouter `drop = FALSE`, comme dans `matrix_c[1, , drop = FALSE]`, permet de conserver une matrice dans le résultat.

Voici le résultat que vous obtenez pour les codes ci-dessus

Nommez les lignes et les colonnes d'une matrice en R.

Les étiquettes par défaut telles que [,1] et [3,] rendent la sortie difficile à lire dès qu'une matrice a une signification réelle. L'argument dimnames, ainsi que les fonctions de remplacement rownames() et colnames(), ajoutent des étiquettes textuelles qui sont ensuite conservées avec la matrice lors des opérations cbind(), t() et de chaque découpage.

# Name the rows and columns while the matrix is built
sales <- matrix(1:6, nrow = 2, ncol = 3,
                dimnames = list(c('north', 'south'), c('q1', 'q2', 'q3')))

# Or attach the names afterwards
rownames(sales) <- c('north', 'south')
colnames(sales) <- c('q1', 'q2', 'q3')

# Read the names back as a list of two character vectors
dimnames(sales)

# Names make label based slicing possible
sales['north', 'q2']

Une fois les étiquettes définies, `sales['north', 'q2']` est bien plus clair que `sales[1, 2]` et est conservé même après un réordonnancement des lignes. Définir un composant `dimnames` sur `NULL` supprime à nouveau cet ensemble d'étiquettes, et une matrice convertie avec `as.data.frame()` conserve directement ses noms de lignes et de colonnes. trame de données.

Matrice OperaFonctions en R : arithmétique, transposition et multiplication

C’est dans les opérations arithmétiques sur les matrices que la règle du type unique s’avère avantageuse. R de base gère l’ensemble des opérations sans package supplémentaire, mais deux opérateurs sont faciles à confondre : * multiplie élément par élément, tandis que %*% effectue une véritable multiplication matricielle et exige que les colonnes de l’opérande de gauche correspondent aux lignes de l’opérande de droite.

m1 <- matrix(1:4, nrow = 2)
m2 <- matrix(5:8, nrow = 2)

m1 + m2          # element by element addition
m1 * m2          # element by element product, NOT matrix multiplication
m1 %*% m2        # true matrix multiplication
t(m1)            # transpose: rows become columns
solve(m1)        # inverse, for a square matrix that is not singular

rowSums(m1)      # one total per row
colMeans(m1)     # one mean per column
apply(m1, 1, max)   # any function, applied row by row

• t(m): Transpose la matrice, donc l'élément [i, j] devient [j, i]. Les noms de dimensions sont conservés.
• résoudre(m): Renvoie l'inverse d'une matrice carrée non singulière, et solve(a, b) résout un système linéaire.
• Sommes des lignes / Sommes des colonnes / Moyennes des lignes / Moyennes des colonnes: Documenté comme équivalent à apply() avec sum ou mean, mais beaucoup plus rapide.
• appliquer(m, MARGE, FUN): MARGIN = 1 parcourt les lignes et MARGIN = 2 parcourt les colonnes, pour toute fonction que vous fournissez.
• diagnostic, détection, analyse croisée: Diagonale, déterminant et la forme plus rapide de t(x) %*% y.

Comme ces opérations sont vectorisées, elles remplacent les boucles au lieu de s'y imbriquer. Un résumé qui nécessiterait une boucle imbriquée sur des milliers de cellules se réduit à un simple appel à la fonction colMeans(), ce qui est crucial dès que le volume de données augmente.

Matrice vs DataFrame vs Tableau en R

Dans la console, les matrices, les data frames et les tableaux apparaissent tous rectangulaires, pourtant ils répondent à des questions différentes. Le tableau les présente côte à côte.

# A matrix holds one type only, so mixing coerces everything to character
mixed <- matrix(c(1, 2, 'a', 'b'), nrow = 2)
class(mixed[1, 1])

# Convert between the structures
as.data.frame(matrix_c)
as.matrix(mtcars)

# A matrix is the two dimensional case of an array
is.matrix(matrix_c)
inherits(matrix_c, 'array')

Utilisez une matrice lorsque toutes les cellules contiennent le même type de nombre et que le travail consiste en des calculs arithmétiques. Utilisez une matrice lorsque toutes les cellules contiennent un nombre identique ... trame de données lorsque les colonnes contiennent des types différents, par exemple un nom de caractère à côté d'un prix numérique et d'un facteur. Tendez la main vers un liste Lorsque les éléments ont des longueurs différentes, et pour un tableau lorsqu'un troisième index, tel que le temps ou la région, existe réellement, la conversion dans les deux sens est peu coûteuse avec `as.matrix()` et `as.data.frame()`. Ainsi, la structure s'adapte à la tâche plutôt que l'inverse.

FAQ