Matrices
Une matrice est créée `a l'aide de la fonction matrix. On spécifie le nombre de lignes et le nombre de colonnes via les arguments nrow et ncol, et les valeurs des éléments de la matrice via l'argument (vectoriel) data. Par exemple, pour initialiser une matrice (2 × 3) `a 0, on utilisera :
> x <- matrix(data = 0, nrow = 2, ncol = 3)
> x
[,1] [,2] [,3]
[1,] 0 0 0
[2,] 0 0 0
Si l'on veut remplir la matrice avec des valeurs différentes, les valeurs fournies par le vecteur
data rempliront alors par défaut les colonnes successives :
> x <- matrix(data = c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
> x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
Pour remplir la matrice plutot par ligne, il suffit de spécifier l'argument byrow=TRUE :
> x <- matrix(data = c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3, byrow = TRUE)
> x
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
On peut aussi rajouter des lignes (fonction rbind) ou des colonnes (fonction cbind) a une matrice existante (voire concaténer des matrices). Voici un exemple :
> cbind(x, c(7, 7))
[,1] [,2] [,3] [,4]
[1,] 1 2 3 7
[2,] 4 5 6 7
> rbind(x, c(8, 8, 8))
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 8 8 8
11
> cbind(x, x)
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 2 3 1 2 3
[2,] 4 5 6 4 5 6
On a la possibilité d'attribuer des noms aux lignes et aux colonnes d'une matrice via l'option
dimnames (ces noms doivent ˆetre de type character ). Pour connaıtre les dimensions d'une matrice, on utilise la fonction dim (la fonction length retourne le nombre d'éléments de la matrice
> dim(x)
[1] 2 3
> length(x)
[1] 6
Comment acceder aux valeurs d'une matrice?
> x <- matrix(data = c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
> x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> x[1, 3]
[1] 5
Noter que l'indice de ligne précede toujours l'indice de colonne.
> x[2, ]
[1] 2 4 6
> x[, 3]
[1] 5 6
> x[1:2, 1:2]
[,1] [,2]
[1,] 1 3
[2,] 2 4
Noter que x[,3] est un vecteur car, par défaut, R retourne un objet de la plus petite taille.
La modification des éléments d'une matrice se fait comme pour les vecteurs. On peut également supprimer une ou plusieurs lignes ou colonnes d'une matrice en utilisant des indices négatifs. Par exemple, pour supprimer la 2`eme colonne d'une matrice :
> x <- matrix(data = c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3)
> x
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> x[, -2]
[,1] [,2]
[1,] 1 5
[2,] 2 6
Opérateurs arithmétiques
Les opérateurs arithmétiques agissent aussi bien sur des variables numériques que logiques
(dans ce dernier cas, les valeurs logiques sont converties en valeurs numériques : 0 pour FALSE et 1 pour TRUE). Mis a part les opérateurs classiques, addition (+), soustraction (-), multiplication
(*) et division (/), on notera les 3 autres opérateurs suivants :
-- ^: puissance
-- %% : modulo
-- %/% : division entiere
Ces opérateurs peuvent aussi s'appliquer a des vecteurs (et a des matrices) ; dans ce cas, attention, l'opération est effectuée composante par composante :
> x <- 1:10
> x^2
[1] 1 4 9 16 25 36 49 64 81 100
> y <- 1:10
> x + y
[1] 2 4 6 8 10 12 14 16 18 20
> x * y
[1] 1 4 9 16 25 36 49 64 81 100
Si les deux vecteurs n'ont pas la meme taille le plus petit sera "recyclé" autant de fois que nécessaire (avec un warning message)
> x <- 1:10
> y <- 1:3
> x + y
[1] 2 4 6 5 7 9 8 10 12 11
Opérateurs de comparaison
Les opérateurs de comparaison s'appliquent `a deux objets de n'importe quel mode et re-
tournent une valeur logique. En fait les opérateurs opèrent sur chaque élément des objets comparés et retourne donc un objet logique de meme taille :
> x <- 1:10
> y <- (-3:6)^2
> x
[1] 1 2 3 4 5 6 7 8 9 10
> y
[1] 9 4 1 0 1 4 9 16 25 36
> x <= y
[1] TRUE TRUE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE
L'opérateur == (resp !=) vérifie l'égalité (resp. la différence) de deux objets, élément par
élément ; il retourne donc un vecteur logique :
> x <- seq(2, 10, by = 2)
> y <- 2 * (1:5)
> x == y
[1] TRUE TRUE TRUE TRUE TRUE
Opérateurs logiques
Les opérateurs logiques s'appliquent a un ou deux objets de mode logique et retournent une
ou plusieurs valeurs logiques :
-- !x : NON logique
-- x&y : ET logique Vrai si x et y sont vrais.
-- x&&y : idem mais sur les premiers éléments de x et y
-- x|y : OU logique, x|y Vrai si x ou y ou les deux sont vrais.
-- x||y : idem mais sur les premiers éléments de et y
-- x or y : OU exclusif Vrai si x ou y sont vrais.
Voici quelques exemples d'utilisation d'operateurs logiques.
suite <- 1:12
> !(suite >6)
[1] TRUE TRUE TRUE TRUE TRUE TRUE FALSE FALSE FALSE FALSE FALSE
FALSE
> suite <= 6 & suite >= 6
[1] FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE
FALSE
> suite <= 6 && suite >= 6
[1] FALSE
> suite <= 6 | suite >= 6
[1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
> suite <= 6 || suite >= 6
[1] TRUE
Fonctions mathématiques simples
Il existe un nombre trés important de fonctions pour manipuler des données numériques
(généralement sous la forme de vecteurs). Outre les fonctions mathématiques de base du type log, exp, cos, abs, sqrt etc. en voici quelques-unes assez courantes :
-- sum(x), prod(x) : somme, produit des éléments de x,
-- min(x), max(x) : minimum, maximum des éléments de x,
-- which.min(x), which.max(x) : indice du min, max des éléments de x,
-- length(x) : nombre d'éléments de x,
-- rev(x) : inverse l'ordre des éléments de x,
-- sort(x) : trie les éléments de x dans l'ordre croissant,
x=c(1, 6, 15, 20, 15, 6, 1)
> sum(x)
[1] 64
> max(x)
[1] 20
> which.max(x)
[1] 4
> sort(x, decreasing = TRUE)
[1] 20 15 15 6 6 1 1
Calcul matriciel
R offre des facilités pour le calcul matriciel. En voici quelques unes :
-- x%*%y : produit de deux matrices,
-- t(x) : transposée de x,
-- diag(x) : extrait la diagonale d'une matrice x (dans ce cas renvoie un vecteur) ou crée
une matrice diagonale de diagonale x,
-- solve(x) : matrice inverse de x
-- solve(A,b) : résout le syst`eme linéaire Ax = b,
-- eigen(x) : calcule les valeurs et vecteurs propres de x.