Les salles de TP et le systeme d’exploitation

En TP, les ordinateurs sont équipés d’un système d’exploitation linux. Contrairement à Windows ou Mac, Linux offre de nombreuses distributions libres et gratuites. La plupart des distributions Linux sont reconnues pour leur style épuré et leur simplicité. Certains réflexes que vous avez acquis sur d’autres systèmes d’exploitation peuvent être differents (touches racourci), mais vous verrez vite que cet environnement simplifie peut avoir des avantages. Sous Linux, pour demarrer la session R, il vous faudra ouvrir un terminal (vous trouverez ce terminal dans les logiciels de votre ordinateur, l’icône correspond à un petit écran noir). Par défaut, vos feuilles de TP seront ouvertes par l’éditeur de script de Linux. Cet éditeur interprète directement le language du script, et devrait faire apparaître les éléments du script de couleurs différentes. Si vous travaillez avec Windows et voulez avoir cette fonctionalité, et qu’il n’est pas installé, vous pouvez télécharger et installer le logiciel gratuit gedit.

R en bref

R est un logiciel libre, multiplateforme et gratuit qui permet de faire des statistiques. C’est ajourd’hui un des outils informatiques phares dans le domaine, en particulier en biologie. Il s’appuie sur un langage informatique et un environnement propre (R). R exsite depuis plus de 25 ans, il est gratuit, constamment amélioré par une très large communauté ouverte de chercheurs et de passionnés. R fonctionne en ligne de commandes, ce n’est donc pas un logiciel presse bouton. Ces commandes peuvent être annotées et stockées sous forme de texte appelées script. Un avantage énorme de ce fonctionnement permet de sauvegarder l’ensemble des opérations qui ont été faites, de les échanger, de les adapter, et de les améliorer.

Le script et les commentaires

Vous avez ici une feuille de script, une feuille de script est une série de commentaires pour vous aider à comprendre une série de commandes qui permettent d’interagir avec votre ordinateur. Les commentaires de ces feuilles sont écrits pour le langage R que vous allez apprendre durant ces séances. Chaque ligne de commentaire est précédée d’un signe dièse (#). Ainsi quand vous copierez et collerez ces commentaires lors d’une session R, ils ne seront pas lus comme des ordres pour votre machine.

Les commentaires sont utiles, car ils permettent d’avoir des indications sur les explications des commandes qui seront envoyées à l’ordinateur. Nous vous conseillons donc de sauvegarder cette feuille de script, mais aussi de la compléter avec vos propres commentaires ou réponses aux exercices. Vous conserverez ainsi une trace de votre TP que vous pourrez imprimer, et reproduire dans R.

1. Utilisation de R comme d’une calculatrice

Démarrez R. Pour cela ouvrez le terminal et tapez R. On vous demandera de taper un certain nombre de commandes contenues dans les feuilles de script, de les copier/coller et les analyser et parfois de les compléter.

Notez que la ligne de commande démarre par le signe \(>\). Cela signifie que R attend vos commandes (vos ordres). Si ce n’est pas le cas, R attend autre chose: dans ce cas
- 1.soit rien n’apparait (il faut alors interagir avec une autre fenêtre (un graphique ou bien l’éditeur du jeu de donnée). - 2. soit un + apparait en début de ligne, ce qui veut dire que votre commande est incomplète.

R permet de faire des calculs simples, en écrivant des op?rations qui font intervenir des vecteurs (des nombres) et des opérateurs (signes de calcul)

1+1.1 
## [1] 2.1

Q1. Que ce passe t’il à l’execution de cette commande ?

Après l’exécution de la commande le résultat de l’opération est imprimé dans la console. Notez que la virgule correspond au point.

De quoi le résultat est-il précédé ?
Le résultat est précédé d’un numéro entre crochets, ce numéro indique l’indice (la position) du premier élément de la ligne

10/2 
## [1] 5

Dans R, les opérateurs +,-, *,/, %/%, %% permettent respectivement de faire des additions, soustractions, multiplications, divisions, divisions entières et obtenir le reste entier.

L’opérateur \(;\) permet de produire deux commandes sur la même ligne

10/2; 10%%2
## [1] 5
## [1] 0

Il est ainsi possible de faire des opérations multiples sur une même ligne

10+2*3
## [1] 16

Q2. Que constate - t - on ici ?

La multiplication est prioritaire sur l’addition, R fonctionne comme une calculette scientifique

Pour gérer le flux des opérations, on utilise le double opérateur parenthèse () Comme pour tout opérateur double, toute parenthèse ouverte doit être fermée, sous peine d’un message d’erreur, ou bien d’un retour de R par le signe + qui indique que vous n’avez pas terminé votre commande par exemple:

10+(2*3
    #fait intervenir le signe + ? la ligne, il faut alors taper la parenthèse fermante pour
    #terminer la commande
)
## [1] 16
(10+2)*3
## [1] 36

on le voit ici, les parenthèses permettent de gérer les priorités entre opérations.

L’opérateur “:” permet de faire des suites à intervalle régulier d’entier, il a priorité sur les opérateurs arithmétiques.

1:30
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
## [26] 26 27 28 29 30
1:30*2
##  [1]  2  4  6  8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50
## [26] 52 54 56 58 60

2. Les constantes et les fonctions dans R.

2.1 Les constantes

Par défaut, quel est l’unité des angles dans R?
le radian

\(\pi\) est une constante, sa valeur est accessible en tapant pi. De manière général, \(\pi\) est un objet dans R. Il existe d’autres constantes dans R, vous pouvez y accéder via l’aide en ligne

?pi

Dans linux pour fermer l’aide en ligne, il faut taper q

2.2 Les fonctions

R permet également l’utilisation de fonctions. Ces fonctions permettent également de faire des opérations, de retourner des graphiques, et de faire beaucoup d’autres choses.

cos(pi)
## [1] -1
cos(2*pi)
## [1] 1

L’aide en ligne dans R vous permet de comprendre l’utilisation des fonctions. On peut par exemple, demander l’aide en ligne pour cos.

?cos

Dans l’aide en ligne de la fonction cos, on voit que pour l’utiliser, il faut préciser un argument x cet argument ou variable n’existe pas dans R. Comme on peut le voir lors de la commande suivante.

# x
# Error: object 'x' not found

Il permet juste de vous montrer à quoi doit correspondre x dans la fonction. Vous pouvez le lire dans la suite de l’aide en ligne (usage et arguments). Lors de l’appel à la fonction cos, x doit donc être substitué une valeur numérique ou complexe pour que la fonction retourne un résultat.

Certaines fonctions nécessitent des arguments multiples, ces arguments multiples doivent être séparés par des virgules. C’est le cas de la fonction lm, qui permet de faire des modèles linéaires

?lm

Notez qu’à la fin de l’aide en ligne, vous avez un tuteur. C’est à dire un exemple de ce que la fonction peut produire. Pour exécuter ce tuteur et voir ce qui se passe, on tape par exemple.

example(cos)
## 
## cos> x <- seq(-3, 7, by = 1/8)
## 
## cos> tx <- cbind(x, cos(pi*x), cospi(x), sin(pi*x), sinpi(x),
## cos+                tan(pi*x), tanpi(x), deparse.level=2)
## Warning in tanpi(x): NaNs produced
## 
## cos> op <- options(digits = 4, width = 90) # for nice formatting
## 
## cos> head(tx)
##           x cos(pi * x... cospi(x) sin(pi * x... sinpi(x) tan(pi * x... tanpi(x)
## [1,] -3.000    -1.000e+00  -1.0000    -3.674e-16   0.0000     3.674e-16   0.0000
## [2,] -2.875    -9.239e-01  -0.9239    -3.827e-01  -0.3827     4.142e-01   0.4142
## [3,] -2.750    -7.071e-01  -0.7071    -7.071e-01  -0.7071     1.000e+00   1.0000
## [4,] -2.625    -3.827e-01  -0.3827    -9.239e-01  -0.9239     2.414e+00   2.4142
## [5,] -2.500     3.062e-16   0.0000    -1.000e+00  -1.0000    -3.266e+15      NaN
## [6,] -2.375     3.827e-01   0.3827    -9.239e-01  -0.9239    -2.414e+00  -2.4142
## 
## cos> tx[ (x %% 1) %in% c(0, 0.5) ,]
##          x cos(pi * x... cospi(x) sin(pi * x... sinpi(x) tan(pi * x... tanpi(x)
##  [1,] -3.0    -1.000e+00       -1    -3.674e-16        0     3.674e-16        0
##  [2,] -2.5     3.062e-16        0    -1.000e+00       -1    -3.266e+15      NaN
##  [3,] -2.0     1.000e+00        1     2.449e-16        0     2.449e-16        0
##  [4,] -1.5    -1.837e-16        0     1.000e+00        1    -5.444e+15      NaN
##  [5,] -1.0    -1.000e+00       -1    -1.225e-16        0     1.225e-16        0
##  [6,] -0.5     6.123e-17        0    -1.000e+00       -1    -1.633e+16      NaN
##  [7,]  0.0     1.000e+00        1     0.000e+00        0     0.000e+00        0
##  [8,]  0.5     6.123e-17        0     1.000e+00        1     1.633e+16      NaN
##  [9,]  1.0    -1.000e+00       -1     1.225e-16        0    -1.225e-16        0
## [10,]  1.5    -1.837e-16        0    -1.000e+00       -1     5.444e+15      NaN
## [11,]  2.0     1.000e+00        1    -2.449e-16        0    -2.449e-16        0
## [12,]  2.5     3.062e-16        0     1.000e+00        1     3.266e+15      NaN
## [13,]  3.0    -1.000e+00       -1     3.674e-16        0    -3.674e-16        0
## [14,]  3.5    -4.286e-16        0    -1.000e+00       -1     2.333e+15      NaN
## [15,]  4.0     1.000e+00        1    -4.899e-16        0    -4.899e-16        0
## [16,]  4.5     5.511e-16        0     1.000e+00        1     1.815e+15      NaN
## [17,]  5.0    -1.000e+00       -1     6.123e-16        0    -6.123e-16        0
## [18,]  5.5    -2.450e-15        0    -1.000e+00       -1     4.082e+14      NaN
## [19,]  6.0     1.000e+00        1    -7.348e-16        0    -7.348e-16        0
## [20,]  6.5    -9.803e-16        0     1.000e+00        1    -1.020e+15      NaN
## [21,]  7.0    -1.000e+00       -1     8.573e-16        0    -8.573e-16        0
## 
## cos> options(op)

D’autres fonctions admettent également des arguments qui peuvent être multiples, mais leur nombre n’est pas spécifié à priori. Dans ce cas, ces arguments apparaissent sous la forme de …

?c()

La fonction c est une fonction importante car elle permet d’entrer une suite de données en format vectoriel.

c(1,3,1)
## [1] 1 3 1

3. Les différents type d’objets dans R, l’assignation et l’indexation de ces objets

Au delà de la manipulation de nombres et de chiffres, R permet de manipuler différents types d’objet. Il peut s’agir de vecteurs (vectors) (suite d’élément de même nature), des matrices (matrix), des tableaux de tableaux (arrays), des jeux de données (data.frame), des listes (list) (ensemble d’éléments de nature diverse). L’accès aux éléments de ces objets se fait par une technique appelée indexation.

3.1 Les vecteurs

Pour créer un vecteur conntenant des objets de même type, on utilise la fonction c()

c(1,3,1)
## [1] 1 3 1

Il est possible de conserver le résultat de cette commande en la stockant dans un objet, on parle encore d’assignation

a <- c(1,3,1)

l’opérateur d’assignation est <-, il est possible aussi d’utiliser le signe =, mais on préfèrera l’utiliser pour spécifier des arguments dans les fonctions.

a
## [1] 1 3 1

On peut ensuite faire des opérations sur cet objet

a*2
## [1] 2 6 2

Ou bien regarder des caractéristiques de cet objet comme sa longeur ou son mode

mode(a)
## [1] "numeric"
length(a)
## [1] 3

Pour construire un vecteur contenant des chaînes de caractères, ces dernières doivent être précédées et suivies du double opérateur ” pour les disinguer des objets R ou des valeurs numériques

b<-c("jiji", "jojo")
b
## [1] "jiji" "jojo"

Q3. Obtenez le mode et la longeur de b

mode(b); length(b)
## [1] "character"
## [1] 2

La coercition: tapez la commande suivante

a1 <- c(a,b)
a1
## [1] "1"    "3"    "1"    "jiji" "jojo"
length(a1)
## [1] 5
mode(a1)
## [1] "character"

Q4. Que s’est-il passé.

les chiffres ont été transformé en mode caractères (ils sont entre guillemets) de sorte que les éléments du vecteur soient compatibles, on parle de coercition, comme un vecteur ne peux être composer que d’un seul type d’élément, R se débrouille pour les rendre compatible entre eux

3.2 L’indexation numérique sur un vecteur

On peut extraire une partie d’un objet en fournissant l’emplacement d’un ou de plusieurs éléments que l’on veut ensuite manipuler. L’indexation se fait grace au double opérateur []

a1[2]
## [1] "3"
a1[c(2,4)]
## [1] "3"    "jiji"
a1[-2]
## [1] "1"    "1"    "jiji" "jojo"

Q5. Que fait le signe - ici ?

il permet d’enlever le deuxième élément dans a1

3.3 Les booléens

En plus des vecteurs numériques ou de type chaines de caractères, il existe des vecteurs de booléens (vrai/faux) (logical dans R). Ces vecteurs sont utiles car ils permettent de faire des comparaisons.

b1<-3:10
b1>5
## [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE
b1>=5
## [1] FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
b1==1
## [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
a1=="jiji"
## [1] FALSE FALSE FALSE  TRUE FALSE
b2<-b1==1
mode(b2)
## [1] "logical"
length(b2)
## [1] 8

Il est possible de combiner les comparaisons avec les opérateurs et (&) ou ou (|)

Q6. Comparez le résulat de ces deux commandes

b1>5 & b1<7
## [1] FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE
b1<5 | b1>7
## [1]  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE  TRUE

La commande ressort un vecteur booléens (composer d’éléments de type logical) dans le premier cas, on a vrai quand la valeur des éléments de b1 sont à la fois supérieurs à 5 et inférieurs à 7 dans le second cas, on a vrai quand l’élément de b1 est inférieur à 5 ou quand il est supérieur à 7

la fonction which() permet d’indiquer l’emplacement des éléments dans un vecteur si ils satisfassent à la condition vrai

b3 <- b1 >= 5
which(b3)
## [1] 3 4 5 6 7 8

Cette fonction peut être utile pour faire de l’indexaction numérique.

b1[which(b3)]
## [1]  5  6  7  8  9 10

Cette commande permettra d’extraire les valeurs de b3 supérieures ou égales à 5

b1[which(b1 >= 5)]
## [1]  5  6  7  8  9 10

Cette seconde commande est équivalente.

3.4 L’indexation logique

b3
## [1] FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE  TRUE
b1[b3]
## [1]  5  6  7  8  9 10
b1[b1 >= 5]
## [1]  5  6  7  8  9 10

Plus compacte, cette indexation permet d’extraire les valeurs pour lesquelles l’indice correspond à vrai (TRUE). Ce mode d’indexation est très utilisé dans R. Il permet de se passer de which.

3.5 Les matrices

Les matrices sont des vecteurs organisés en plusieurs colonnes et lignes

M <- matrix(1:10,5,2)
M
##      [,1] [,2]
## [1,]    1    6
## [2,]    2    7
## [3,]    3    8
## [4,]    4    9
## [5,]    5   10

Elles sont remplies par défaut colonnes par colonnes, le premier élément correspond au vecteur de données, le second au nombre de lignes, puis de colonnes.

M1 <- matrix(1:10, 5, 2, byrow=T)
M1
##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
## [3,]    5    6
## [4,]    7    8
## [5,]    9   10

On peut aussi les remplir en lignes en spécifiant l’option byrow=T
On peut facilement faire du calcul matriciel dans R. La transposée est obtenu par la fonction \(t()\)

t(M1)
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10

Le produit matriciel est obtenu par l’opérateur %*%

t(M1)%*%M 
##      [,1] [,2]
## [1,]   95  220
## [2,]  110  260

Il est également possible d’indexer les matrices en lignes et en colonnes pour cela, il faut utiliser la virgule. #### Q7. Interprétez les commandes suivantes:

M1[1,]
## [1] 1 2
M1[,1]
## [1] 1 3 5 7 9
M1[-2,]
##      [,1] [,2]
## [1,]    1    2
## [2,]    5    6
## [3,]    7    8
## [4,]    9   10
M1[1:2,]
##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
M1[M1[,1]>3,]
##      [,1] [,2]
## [1,]    5    6
## [2,]    7    8
## [3,]    9   10

Les matrices comme les vecteurs peuvent être de type numeric, character ou logical. Elles ne peuvent pas contenir des éléments de differents modes.
En plus d’une longeur et d’un mode, on peut extraire leur nombre de colonnes et lignes

dim(M)
## [1] 5 2
dim(M1)
## [1] 5 2
# La première valeur correspond au nombre de lignes, la seconde au nombre de colonnes

3.6 Les arrays (tableaux de tableaux)

Les arrays sont des matrices étendues à plusieurs dimensions

array(1:30,dim=c(2,5,3))
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   11   13   15   17   19
## [2,]   12   14   16   18   20
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   21   23   25   27   29
## [2,]   22   24   26   28   30

Cette commande permet d’organiser les valeurs 1 à 30 dans 3 matrices de 2 lignes et 5 colonnes.
Le remplissage se fera par matrices, colonnes, et lignes

A<-array(1:30,dim=c(2,5,3))
dim(A)
## [1] 2 5 3

Q8. indexez A de sorte à obtenir la deuxième matrice; ensuite indexez A de sorte à obtenir l’ensemble des premières colonnes

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

3.7 Les listes

Les listes sont des objets qui permettent de stocker des objets de différents modes ou type. Elles sont obtenues grâce à la fonction \(list()\). De très nombreuses fonctions de R renvoient des objets de type list. Il est essentiel de savoir les indexer.

list(A, b1)
## [[1]]
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   11   13   15   17   19
## [2,]   12   14   16   18   20
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   21   23   25   27   29
## [2,]   22   24   26   28   30
## 
## 
## [[2]]
## [1]  3  4  5  6  7  8  9 10
b4 <- list(A, b1)
b4
## [[1]]
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   11   13   15   17   19
## [2,]   12   14   16   18   20
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   21   23   25   27   29
## [2,]   22   24   26   28   30
## 
## 
## [[2]]
## [1]  3  4  5  6  7  8  9 10

la longeur d’une liste correspond au nombre d’objets qu’elle contient

length(b4)
## [1] 2

Pour indexer une liste on utilise l’opérateur [[]]; il permet d’extraire l’objet

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

Il est possible ensuite d’extraire des valeur sur cet objet

b4[[2]][3]
## [1] 5

Cette commande extrairera le troisième élément du deuxième objet

Le mode d’une liste est de type list.

mode(b4)
## [1] "list"

Les listes permettent également l’indexation nominale, pour cela il faut renseigner les noms des éléments de la liste à leur création

b5 <- list(objet1=A ,objet2=b1)
b5
## $objet1
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   11   13   15   17   19
## [2,]   12   14   16   18   20
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   21   23   25   27   29
## [2,]   22   24   26   28   30
## 
## 
## $objet2
## [1]  3  4  5  6  7  8  9 10
Q9. Qu’est qui a changé entre b4 et b5

les objets de la liste sont précédés par leur nom plutôt que par les doubles crochets autour de l ’indice

names(b5)
## [1] "objet1" "objet2"

Pour indexer une liste par nom, on utilise l’opérateur $

b5$objet1
## , , 1
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    3    5    7    9
## [2,]    2    4    6    8   10
## 
## , , 2
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   11   13   15   17   19
## [2,]   12   14   16   18   20
## 
## , , 3
## 
##      [,1] [,2] [,3] [,4] [,5]
## [1,]   21   23   25   27   29
## [2,]   22   24   26   28   30

3.8 Les jeux de donn?es (data.frame)

En statistique, les jeux de données sont une présentation conventionnelle des données. Ils correspondent à des observations uni ou mulvariées (en lignes) et des variables en colonnes. Ces variables peuvent être de différents mode. Les data.frame sont en fait des listes de vecteur (variables) de même taille. R contient des jeux de données pour s’entrainer.#Un exemple de jeu de données est ToothGrowth

?ToothGrowth
mode(ToothGrowth)
## [1] "list"

les différentes variables peuvent être obtenues grace à names()

names(ToothGrowth)
## [1] "len"  "supp" "dose"

l’indexation de ces jeux de données peut se faire comme pour une matrice ou une liste

ToothGrowth[,1]
##  [1]  4.2 11.5  7.3  5.8  6.4 10.0 11.2 11.2  5.2  7.0 16.5 16.5 15.2 17.3 22.5
## [16] 17.3 13.6 14.5 18.8 15.5 23.6 18.5 33.9 25.5 26.4 32.5 26.7 21.5 23.3 29.5
## [31] 15.2 21.5 17.6  9.7 14.5 10.0  8.2  9.4 16.5  9.7 19.7 23.3 23.6 26.4 20.0
## [46] 25.2 25.8 21.2 14.5 27.3 25.5 26.4 22.4 24.5 24.8 30.9 26.4 27.3 29.4 23.0
ToothGrowth$len
##  [1]  4.2 11.5  7.3  5.8  6.4 10.0 11.2 11.2  5.2  7.0 16.5 16.5 15.2 17.3 22.5
## [16] 17.3 13.6 14.5 18.8 15.5 23.6 18.5 33.9 25.5 26.4 32.5 26.7 21.5 23.3 29.5
## [31] 15.2 21.5 17.6  9.7 14.5 10.0  8.2  9.4 16.5  9.7 19.7 23.3 23.6 26.4 20.0
## [46] 25.2 25.8 21.2 14.5 27.3 25.5 26.4 22.4 24.5 24.8 30.9 26.4 27.3 29.4 23.0

Il est d’usage dans les jeux de données d’avoir des facteurs (variables catégoriques). Les facteurs sont des vecteurs particulier contenant différentes catégories (levels). Ces vecteurs sont numériques, mais attention !!! Les valeurs numériques ne sont pas des entiers ou des réels, il s’agit plutot d’un codage binaire permettant de spécifier quelle est la catégorie correspondant à chaque élément (variable qualitative).

str(ToothGrowth)
## 'data.frame':    60 obs. of  3 variables:
##  $ len : num  4.2 11.5 7.3 5.8 6.4 10 11.2 11.2 5.2 7 ...
##  $ supp: Factor w/ 2 levels "OJ","VC": 2 2 2 2 2 2 2 2 2 2 ...
##  $ dose: num  0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 ...

On voit ici que le deuxième vecteur est un facteur

is.factor(ToothGrowth[,2])
## [1] TRUE

Q10. A l’aide de l’indexation, extraire les lignes du tableau qui correspondent à des cobayes pour lesquels on a donné du jus d’orange et pour lesquels les odontoblastes mesurent plus de 10 micrometres.

ToothGrowth[ToothGrowth$len>10 & ToothGrowth[,2]=="OJ",]
##     len supp dose
## 31 15.2   OJ  0.5
## 32 21.5   OJ  0.5
## 33 17.6   OJ  0.5
## 35 14.5   OJ  0.5
## 39 16.5   OJ  0.5
## 41 19.7   OJ  1.0
## 42 23.3   OJ  1.0
## 43 23.6   OJ  1.0
## 44 26.4   OJ  1.0
## 45 20.0   OJ  1.0
## 46 25.2   OJ  1.0
## 47 25.8   OJ  1.0
## 48 21.2   OJ  1.0
## 49 14.5   OJ  1.0
## 50 27.3   OJ  1.0
## 51 25.5   OJ  2.0
## 52 26.4   OJ  2.0
## 53 22.4   OJ  2.0
## 54 24.5   OJ  2.0
## 55 24.8   OJ  2.0
## 56 30.9   OJ  2.0
## 57 26.4   OJ  2.0
## 58 27.3   OJ  2.0
## 59 29.4   OJ  2.0
## 60 23.0   OJ  2.0

Il est possible de calculer des paramètres statistiques simples sur un jeu de données.
Pour les variables numériques (mean, min, max, median, range, var, sd) renvoient respectivement la moyenne, le minimum, le maximum, l’étendue, la variance et l’écart type.

Q11. Calculez tous ces paramètres pour la variable longeur des odontoblastes pour les cobayes ayant reçu de la vitamine C. Faire de même pour les cobayes ayant reçu du jus d’orange.

La fonction quantile permet d’extraire le quantile correspondant à une fréquence cumulée donnée.

quantile(ToothGrowth[,1], 0.025)
##  2.5% 
## 5.485

On a ici la valeur pour laquelle 2.5% de la distribution est atteinte.

Pour les variables qualitative (facteur), on peut avoir une idée de leur distribution grâce à table()

table(ToothGrowth[,2])
## 
## OJ VC 
## 30 30

summary() permet d’avoir une idée de la variabilité, variable par variable en fonction de son type

summary(ToothGrowth)
##       len        supp         dose      
##  Min.   : 4.20   OJ:30   Min.   :0.500  
##  1st Qu.:13.07   VC:30   1st Qu.:0.500  
##  Median :19.25           Median :1.000  
##  Mean   :18.81           Mean   :1.167  
##  3rd Qu.:25.27           3rd Qu.:2.000  
##  Max.   :33.90           Max.   :2.000

Une fonction sympathique pour aller plus vite…

tapply(ToothGrowth$len, ToothGrowth$supp, summary)
## $OJ
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    8.20   15.53   22.70   20.66   25.73   30.90 
## 
## $VC
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    4.20   11.20   16.50   16.96   23.10   33.90

Que fait tapply ?

Importer un jeu de données, le modifier, et le sauvegarder

1. Faire des graphiques simples

Q12. Créez un répertoire que vous appelerez stat et un sous-répertoire data dans votre répertoire personnel. Attention R est sensible à la capitalisation des caractères.

Téléchargez le fichier “turtle.tsv” dans le sous-répertoire data

Ouvrez ce jeu de données dans le tableur (libreoffice Calc).

Ouvrez ce jeu de données dans un éditeur de texte

Le séparateur de champ correspond à la manière dont sont séparés les différents champs dans ce jeu de données.

Quel est il dans ce jeu de données ?

Il s’agit ici d’un séparateur tabulation

Regardez les propriétés de de ce jeu de donnée à l’aide de la souris et de l’alinéa propriété. A l’aide de cet outil, notez l’emplacement du fichier dans l’arborescence de fichier

Lancez R, pour cela tapez R dans l’émulateur de terminal, puis entrée.

3. Chargez les données grâce aux commandes suivantes

read.table(file="turtle.tsv",sep="\t",dec=",",header=T)
##    sex length width height
## 1    f     98    81     38
## 2    f    103    84     38
## 3    f    103    86     42
## 4    f    105    86     40
## 5    f    109    88     44
## 6    f    123    92     50
## 7    f    123    95     46
## 8    f    133    99     51
## 9    f    133   102     51
## 10   f    133   102     51
## 11   f    134   100     48
## 12   f    136   102     49
## 13   f    137    98     51
## 14   f    138    99     51
## 15   f    141   105     53
## 16   f    147   108     57
## 17   f    149   107     55
## 18   f    153   107     56
## 19   f    155   115     63
## 20   f    155   117     60
## 21   f    158   115     62
## 22   f    159   118     63
## 23   f    162   124     61
## 24   f    177   132     67
## 25   m     93    74     37
## 26   m     94    78     35
## 27   m     96    80     35
## 28   m    101    84     39
## 29   m    102    85     38
## 30   m    103    81     37
## 31   m    104    83     39
## 32   m    106    83     39
## 33   m    107    82     38
## 34   m    112    89     40
## 35   m    113    88     40
## 36   m    114    86     40
## 37   m    116    90     43
## 38   m    117    90     41
## 39   m    117    91     41
## 40   m    119    93     41
## 41   m    120    89     40
## 42   m    120    93     44
## 43   m    121    95     42
## 44   m    125    93     45
## 45   m    127    96     45
## 46   m    128    95     45
## 47   m    131    95     46
## 48   m    135   106     47

le jeu de données s’affiche dans la console, mais on ne peut rien en faire…

d <- read.table(file="turtle.tsv",sep="\t",dec=",",header=T)
# file   -> le chemin vers le fichier, entre guillemets
# sep    -> le séparateur de champ
# dec    -> le séparateur décimal
# header -> y-a-t-il des en-têtes de colonnes dans le fichier ? (vrai ou faux)

le jeu de données ne s’affiche plus, mais il est stocké dans l’objet d
On peut ensuite en exploiter le contenu

# edit(d)

Si on veut changer des valeurs dans le tableau il faudra alors taper la commande d<-edit(d)
On peut aussi effectuer les changements voulus aux endroits voulu grâce à l’indexation et l’assignation. N’oubliez pas de quitter l’éditeur de données pour retourner dans R.

Q13.

Quelques erreurs classiques dans le chargement…

# d <- read.table(file="turtle.tvs",sep="\t",dec=",",header=T)

Q. Pourquoi cette commande est-elle impropre ?

mauvais nom de fichier (attention dans windows on ne voit pas toujours les extensions)

# d <- read.table(file="turtle.tsv",sep=" ",dec=",",header=T)

Q. Pourquoi cette commande est-elle impropre ?

mauvais séparateur

# d <- read.table(file="turtle.tsv",sep="\t",dec=",",header=F)

Q. Pourquoi cette commande est-elle impropre ?

l’entête n’est pas renseigné, les vecteurs seront tous de mode caractères car on va mélanger des valeurs avec des chaînes de caractères

En conclusion: toujours commencer par vérifier que le jeu de données est correctement chargé. Ensuite, vérifier que que les variables (contenu des colonnes) ont le type qu’elles doivent avoir ! et que la dimension de la matrice des données est la bonne (bon nombre de colonnes et de lignes ??)
Il suffit pour cela de cliquer sur le nom de colonne dans la fenêtre créée par la fonction edit()
ou bien de d’interroger R sur les dimenssions du table

nrow(d)
## [1] 48
ncol(d)
## [1] 4
dim(d)
## [1] 48  4

Contenu du tableau

str(d)
## 'data.frame':    48 obs. of  4 variables:
##  $ sex   : chr  "f" "f" "f" "f" ...
##  $ length: int  98 103 103 105 109 123 123 133 133 133 ...
##  $ width : int  81 84 86 86 88 92 95 99 102 102 ...
##  $ height: int  38 38 42 40 44 50 46 51 51 51 ...

On constate que la première colonne qui devrait être une catégorie est un vecteur, on se propose donc d’en faire un facteur

d[,1]<-as.factor(d[,1])
str(d)
## 'data.frame':    48 obs. of  4 variables:
##  $ sex   : Factor w/ 2 levels "f","m": 1 1 1 1 1 1 1 1 1 1 ...
##  $ length: int  98 103 103 105 109 123 123 133 133 133 ...
##  $ width : int  81 84 86 86 88 92 95 99 102 102 ...
##  $ height: int  38 38 42 40 44 50 46 51 51 51 ...

NB une des rares choses qui dépend de la machine et du système d’exploitation sur lequel R est installé c’est la façon d’indiquer le chemin vers un fichier.
Dans ce qui précède, R va chercher le fichier “beak_size” dans le répertoire courant. Si jamais le fichier en question était dans un répertoire appelé “stat” dans mon répertoire personnel, ça donnerait

Sous Linux

# d <- read.table(file="~/stat/data/turtle.tsv",sep="\t",dec=",",header=T)

Sous Windows

# d <- read.table(file="c:/Mes Documents/stat/data/turtle.tsv",sep="\t",dec=",",header=T)

R peut aussi lire directement des fichiers excel, openoffice ou bien aller interroger des bases de donn?és Access ou SQL. Personnellement je déconseille les deux premières fonctionnalités, sources de nombreux ennuis à cause des fonctions de formatage automatique qui existent dans la plupart des tableurs.

write.table() permet d’écrire un jeu de données et de le sauvegarder dans votre ordinateur.

Ici on va sélectionner uniquement les valeurs des mâles pour les stocker dans un nouveau fichier “male.tsv”.
Le fichier sera stocké dans le répertoire courant actuel, puisqu’aucun chemin n’est détaillé dans la commande.
Notez ici qu’on va choisir un séparateur de champ type tabulation. Il faut absolument éviter que le séparateur de champ serve à quelque chose d’autre pour pouvoir facilement ouvrir le fichier.

write.table(d[d$sex=="m",], file="male.tsv", sep="\t")

4. Quelques graphiques simples

4.1 Barplot and Piechart

Pour représenter des variables de type catégoriques, on utilise les graphiques en barres (barplot) ou bien en camembert (pie)

pie(table(d$sex))

barplot(table(d$sex))

Q14. Dans ces graphiques, modifiez la couleur des barres ou des portions pour les mâles et les femelles (pour cela consultez l’aide en ligne de pie et barplot), n’hésitez pas à consulter les exemples pour vous donner des idées.

barplot(table(d$sex), col=c("pink", "blue"))

4.2 Histogrammes pour les variables quantitatives

Représentation de l’histogramme pour la longueur de la carapace.

hist(d$len)

Notez qu’il est possible de créer vous même votre découpage de classe (voir l’aide en ligne). Par défaut le découpage est fait de sorte qu’il soit joli à regarder (en terme de bornes inférieures et supérieures pour les classes et en termes de nombre de barres d’histogramme). On peut grâce à cela représentez sur le même graphique le découpage pour les mâle et les femelles.
Dans un premier temps on représente tout, mais on va assigner les valeurs produites par la fonction pour ensuite conserver le même découpage et superposer le graphique des mâles sur le précédent. Par différences on trouvera les fr?éuences des femelles.

HH<-hist(d$len, col="pink")
names(HH)
## [1] "breaks"   "counts"   "density"  "mids"     "xname"    "equidist"
HH$breaks
##  [1]  90 100 110 120 130 140 150 160 170 180
hist(d$len[d$sex=="m"], col="blue", breaks=HH$breaks, add=T)

Plus compliqué mais en utilisant une combinaison de hist et barplot

h1 <- hist(d$len[d$sex=="m"],breaks=HH$breaks,plot=F)
h2 <- hist(d$len[d$sex=="f"],breaks=HH$breaks,plot=F)
barplot(rbind(h1$counts,h2$counts),beside=T,col=c("blue","pink"),names.arg=h1$mids,xlab="taille des tortues",ylab="nombre")
legend("topleft",legend=c("mâles","femelles"),fill=c("blue","pink"), bty="n")

4.3 Graphiques type Boîtes à moustache

Quand on compare une variable qualitative à une variable quantitaive il est d’usage de réaliser des graphiques type boîtes à moustaches.

boxplot(d$len~d$sex)
#ou
plot(d$len~d$sex)

Le graphique type boite à moutache représente la valeur médiane, l’espace interquartile, le minimum et le maximum, sauf si ces valeurs sont plus extrèmes que le quartile inférieur ou supérieur -/+ 1.5 fois l’espace interquartile. Dans ce cas, alors elles apparaissent comme des points isolés, et la valeur la plus extrème de la barre fine s’arrête au maximum ou minimum en ignorant ces valeurs. Notez l’utlisation de l’opérateur de formule ~ qui veut dire en fonction de. Il est là aussi possible d’habiller le graphique avec de la couleur.

plot(d$len~d$sex, col=c("pink", "blue"))

Par défaut, les couleurs correspondent à l’ordre des niveaux (par ordre alphabétique f est avant m).

4.4Graphiques bivariés

plot(d$width~d$len)

En utilisant l’opérateur de formule, la valeur à gauche de ~ correspond aux ordonnées, celle qui est à droite aux abscisses.

pairs(d[,2:4])

Q15. Que fait la fonction pairs ?

Elle permet d’obtenir sur une meme fenetre graphique toutes les combinaison de graphique bivariés à partir des colonnes sélectionnées dans le jeu de données d

4.5 Interagir avec la fenêtre graphique

# identify(d$width~d$len)

identify() permet de savoir à quelle observation correspond quel point. La fonction locator(), utilisée telle quelle permet en cliquant sur le graphique de connaître les coordonnées en abscisse et en ordonnées.

La forme des symboles, la couleur des points et leur tailles peuvent être changées, pour cela il faut alors spécifier, pour chaque observation quelles en seront les caractéristiques. On utilise pour cela l’indexation factorielle. Par exemple si on veut obenir un vecteur de couleur correspondant au genre des tortues, on fait:

# c("pink", "blue")[d$sex]

Dans le graphique on peut ainsi modifier la couleur des symboles en fonction.

plot(d$width~d$len, col=c("pink", "blue")[d$sex])

La taille des points, leur forme sont obenues respectivement avec les arguments cex et pch. Il existe 25 symboles, les 5 derniers peuvent être rempli de couleur en spécifiant l’argument bg

plot(1:25, 1:25, pch=1:25, bg="blue")

Q16. Constuire le graphique de la largeur en fonction de la longueur, en utilisant deux symboles dont le fond peut être coloré en fonction des deux sexes, une taille de symbole unique équivalent à la valeur 2, et deux couleurs distinctes pour le fond en fonction du sexe également.

plot(d$width~d$len, pch=c(21,22)[d$sex], bg=c("pink", "blue")[d$sex],cex=2)

# Les paramètres graphiques peuvent être modifiés facilement grâce à la fonction par(). 
par(bg="yellow")
par(bg="yellow", col.lab="red")
plot(1:25, 1:25, pch=1:25, bg="blue")

Pour revenir aux paramètres par défaut il suffit de fermer la fenêtre graphique.

#dev.off() # ferme la fenêtre graphique
plot(1:25, 1:25, pch=1:25, bg="blue")

Voir ?par() pour tout ce qui est offert via cette fonction

4.6 Sauvegarder un graphique

# dev.off()
# png(file="symbolesR.png")
# plot(1:25, 1:25, pch=1:25, bg="blue", main="Les symboles dans R")
# dev.off()

L’appel à png fait que les commandes graphiques seront exécutées dans un fichier et non pas dans une fenêtre. La commande dev.off est fondamentale: elle permet de fermer le fichier une fois que l’on a terminé d’afficher le graphique. Si on l’oublie, les commandes graphiques suivantes seront elles aussi exécutées dans le fichier png, en se superposant au premier graphique. Il est possible de sauver le graphique en jpeg en utilisant jpeg, ou mieux en vectoriel en utilisant ps; dans ce cas le fichier sera sauver en postscript

Générer des données régulières ou aléatoires dans R

1. Construction d’un vecteur dont le contenu suit une certaine régularité

v <- rep(1,10)
v
##  [1] 1 1 1 1 1 1 1 1 1 1
v <- 1:10
v
##  [1]  1  2  3  4  5  6  7  8  9 10
v <- seq(1,10,by=2)
v
## [1] 1 3 5 7 9
v <- seq(1,10,length=15)
v
##  [1]  1.000000  1.642857  2.285714  2.928571  3.571429  4.214286  4.857143
##  [8]  5.500000  6.142857  6.785714  7.428571  8.071429  8.714286  9.357143
## [15] 10.000000

Q17, que font rep() et seq() ?

rep() répète un vecteur un nombre de fois donné

seq() permet de faire une séquence régulière soit par incrément régulier (by), soit par pas régulier en spécifiant le nombre de pas entre le début et la fin de la séquence.

2. rééchantillonage

sample(v)
##  [1]  8.714286  8.071429  3.571429  4.214286  6.142857  4.857143  2.928571
##  [8]  2.285714  9.357143  1.000000  7.428571 10.000000  1.642857  6.785714
## [15]  5.500000

3. réchantillonage avec remise

sample(v, replace=T)
##  [1]  3.571429  6.142857  4.214286  1.642857  2.285714  2.928571  2.928571
##  [8]  5.500000  7.428571  9.357143  1.000000  2.928571 10.000000  5.500000
## [15]  9.357143

4. construction d’un vecteur de nombres aléatoires suivant la loi normale

v <- rnorm(100,mean=1,sd=0.1)

Q.18. Exécutez cette fonction plusieurs fois et comparez le résultat. Que se passe-t-il ?

Le résultat change à chaque éxécution, mais la moyenne de l’échantillon et son écart type est constant (à l’erreur d’échantillonage prêt)

v <- rbinom(100,size=100,p=0.5)

de nombreuses autres distributions sont implémentées dans R… bien pratique quand on veut faire des simulations

La fonction de répartition, la fonction quantile et la fonction densité sont des fonctions amies des fonctions produisant des données aléatoires commençant en rbinom, rnorm, runnif…

5. calcul de la fréquence cumulée pour un quantile donné

loi normale

pnorm(1.645, 0,1)
## [1] 0.9500151

loi de student

pt(1.645, 30)
## [1] 0.9447954

6. calcul du quantile à partir de la fréquence cumulée

loi normale

qnorm(0.95, 0,1)
## [1] 1.644854

loi de student

qt(0.95, 30)
## [1] 1.697261

Création d’une fonction et intervalles de confiances sur la moyenne

1. Créer une fonction

Nous allons créer une fonction permettant d’obtenir l’estimateur de l’erreur type sur la moyenne et l’appliquer pour notre jeu de données.
L’erreur type est définie comme le ratio entre l’estimateur de l’écart type et la racine carré de l’échantillonage.
Notre fonction prendra donc comme unique argument un vecteur de données qui correspondra à l’argument x. Entre les accolades, il faudra préciser l’ensemble des opérations sur cet argument. Notez ici l’utilisation de sqrt() pour obtenir la racine carrée. Il est recommandé d’écrire la fonction sur plusieurs lignes, et ensuite de la copier et la coller depuis sa déclaration jusqu’à la fermeture de l’accolade dans la console R pour qu’elle puisse être mise en mémoire dans la session en cours.

typeerror <- function(x){
  n <- length(x)
  sdx <- sd(x)
  sdx/sqrt(n)
}

typeerror
## function(x){
##   n <- length(x)
##   sdx <- sd(x)
##   sdx/sqrt(n)
## }
mode(typeerror)
## [1] "function"

typeerror() est donc maintenant une fonction qui calculera l’erreur standard sur un échantillon représenté par un vecteur de données. Il est possible donc de l’appliquer sur nos données.

2. Calcul de l’erreur standard pour la taille de l’ensemble des tortues

typeerror(d$len)
## [1] 2.956265

A partir de là il est possible de calculer facilement l’intervalle de confiance pour la moyenne taille sur l’ensemble des tortues (il y a 48 tortues, donc on cherchera les quantiles de la distribution de students à 48-1 degrées de liberté).

mean(d$len)+qt(0.025, 47)*typeerror(d$len)
## [1] 118.7403
mean(d$len)+qt(0.975, 47)*typeerror(d$len)
## [1] 130.6347

Q19. Calculez les intervalles de confiances pour la moyenne des mâles et les femelles, comparez les r?sultats obtenus au boxplot de la taille en fonction du sexe.

mean(d$len[d$sex=="m"])+qt(0.025, 23)*typeerror(d$len[d$sex=="m"])
## [1] 108.4008
mean(d$len[d$sex=="m"])+qt(0.975, 23)*typeerror(d$len[d$sex=="m"])
## [1] 118.3492
mean(d$len[d$sex=="f"])+qt(0.025, 23)*typeerror(d$len[d$sex=="f"])
## [1] 127.0286
mean(d$len[d$sex=="f"])+qt(0.975, 23)*typeerror(d$len[d$sex=="f"])
## [1] 144.9714

3. Réalisation d’une boucle: estimation de l’intervalle de confiance par bootstrap

Le bootstrap est une technique de rééchantillonage avec remise permettant d’avoir une idée de l’erreur d’échantillonage associée à un paramètre. Ici nous allons utiliser les données pour rééchantilloner avec remise et recalculer le paramètre voulu sur l’échantillon 1000 fois (ici la moyenne).

mean(d$len)
## [1] 124.6875
M1<-mean(sample(d$len, replace=T))
M2<-mean(sample(d$len, replace=T))

Comparez les deux valeurs

A l’aide d’une boule nous allons stocké dans l’objet Moyb, le résultat de ce calcul pour 1000 rééchantillonage

Moyb<-NULL

Dans un premier temps, on déclare l’objet Moyb dans lequel seront stockées les données, on lui donne une taille et une valeur inexistante, mais on on le nomme pour éviter un message d’erreur

for (i in 1:1000){
  Moyb[i] <- mean(sample(d$len, replace=T))}

Q20. Que ce passe -t-il ? chaque tour de boucle ?

A chaque tour de boucle i est passe à l’élément suivant dans le vecteur 1 à 1000, ainsi Moyb[i] va stocker une moyenne à partir d’un rééchantillonage avec remise dans \(d\$len\) de même taille que \(d\$len\)

Q21. Dessinez l’histogramme de Moyb, calculez son quantile ? 2.5 et 97.5%. Le comparer avec l’intervalle de confiance obtenu précédemment. A l’aide de la fonction abline tracez un trait vertical rouge sur l’histogramme correspondant à chaque quantile.

hist(Moyb)
q025<-quantile(Moyb, 0.025)
q975<-quantile(Moyb, 0.975)
abline(v=q025)
abline(v=q975)