Quelques fonctions utiles

• getwd() permet de connaître le répertoire dans lequel on travaille.
• dir() permet de connaître le contenu du répertoire de travail.
• setwd("repertoire") permet de changer de répertoire de travail.
• source("script.r") exécute un fichier script.
• save(monobjet,file="monobjet.rdata") permet de sauver l’objet monobjet sous le format R. Il est aussi possible de sauver plusieurs objets dans le même fichier. Par exemple : save(objet1,objet2,file="mesobjets.rdata").
• load("mesobjets.rdata") permet de recharger des objets sauvegardés au cours d’une session précédente.
• write.table(montableau,file="montableau.txt") permet de sauvegarder le tableau de données montableau sous un format .txt.

Noter que l’appel à une fonction se fait toujours sous la forme fonction(arguments, options) et que les paranthèses sont indispensables même sans arguments ni options.

Pour quitter R, il faut utiliser la commande q(). R pose alors la question :

Save workspace image? [y/n/c]:

Si vous répondez y, R sauvegarde le fichier .RData, qui contient tous les objets créés au cours de la session. Si vous répondez n, ces objets sont perdus. Pour continuer la session, il faut répondre par la lettre c. L’historique des commandes est conservé automatiquement dans le fichier .Rhistory.

Le système d’aide

Il existe une aide directement disponible dans R : on y accède en utilisant le ? suivi du nom de la fonction, ou bien help(nom.fonction). Si la fonction appartient à une bibliothèque particulière, il faut que celle-ci soit chargée. En réponse à cette commande d’aide, le logiciel affiche une page comportant :

• le nom de la fonction et le nom de la bibliothèque à laquelle elle appartient,
• le titre de la fonction,
• une brève description de la fonction et de son utilisation,
• une description détaillée des arguments de la fonction, et du type d’objet qu’elle retourne,
• des références, des liens vers des fonctions similaires et des exemples.

Nous pouvons, par exemple, obtenir la documentation de la fonction “mean” avec la commande :

help(mean)

mean    package:base    R Documentation
Arithmetic Mean

Description:

    Generic function for the (trimmed) arithmetic mean.

Usage:

    mean(x, ...)

    ## Default S3 method:
    mean(x, trim = 0, na.rm = FALSE, ...)
    
Arguments:

     x: An R object. Currently there are methods for numeric data
        frames, numeric vectors and dates. A complex vector is
        allowed for ' trim = 0 ' , only.

  trim: the fraction (0 to 0.5) of observations to be trimmed from
        each end of ' x ' before the mean is computed.
 
 na.rm: a logical value indicating whether ' NA ' values should be
        stripped before the computation proceeds.

   ...: further arguments passed to or from other methods.
   
Value:

    For a data frame, a named vector with the appropriate method being
    applied column by column.
    
    If ' trim ' is zero (the default), the arithmetic mean of the values
    5in ' x ' is computed, as a numeric or complex vector of length one.
    If any argument is not logical (coerced to numeric), integer,
    numeric or complex, ' NA ' is returned, with a warning.

    If ' trim ' is non-zero, a symmetrically trimmed mean is computed
    with a fraction of ' trim ' observations deleted from each end
    before the mean is computed.

References:

    Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
    Language_. Wadsworth & Brooks/Cole.

See Also:
    'weighted.mean ' , ' mean.POSIXct '

Examples:

    x <- c(0:10, 50)
    xm <- mean(x)
    c(xm, mean(x, trim = 0.10))
    mean(USArrests, trim = 0.2)

Il existe également une aide au format html permettant l’utilisation d’un moteur de recherche ; on y accède en utilisant help.start() qui ouvre la page d’accueil de l’aide de R, dans la fenêtre d’un navigateur interne. Il existe aussi des commandes permettant une investigation de la documentation à partir de mots-clés :

• la fonction apropos("keyword") retourne la liste de toutes les fonctions qui contiennent dans leur nom, le mot-clé recherché.
• la fonction help.search("keyword") retourne la liste de toutes les fonctions qui contiennent dans leur nom ou dans leur titre, le mot-clé recherché.

La fonction args donne en général la liste des arguments d’une fonction. Par exemple :

args(sort)

## function (x, decreasing = FALSE, ...) 
## NULL

Caractéristiques d’un objet

Type

Les données manipulées par R peuvent être de différents types :

• vecteur : suite d’éléments (une dimension),
• tableau : tableau à k dimensions,
• matrice : tableau à 2 dimensions,
• facteur : suite d’éléments catégoriels avec les différents niveaux possibles,
• tableau de données : ensemble de vecteurs de même longueur,
• séries temporelles : jeu de données de type séries temporelles (avec fréquence, dates),
• liste : liste d’objets.

Mode

Les éléments stockés dans un objet peuvent être de 4 modes différents :

• numérique,
• caractère (entre guillemets),
• complexe,
• logique (TRUE ou FALSE)

Pour connaître le mode d’un objet x, on utilise la fonction mode :

x<-0
mode(x)

## [1] "numeric"

titre<-"coucou"
mode(titre)

## [1] "character"

Seuls les tableaux de données et les listes peuvent contenir des éléments de modes différents.

Taille

La taille d’un objet est le nombre d’éléments qu’il contient. Elle s’obtient à l’aide de la fonction length :

length(x)

## [1] 1

Nom

Le nom d’un objet doit obligatoirement commencer par une lettre et ne peut comporter que des lettres, des chiffres, des espaces soulignés et des points.

Valeur

Quelque soit le mode, une valeur manquante est représentée par NA. Voici quelques remarques sur les valeurs numériques.

• R représente correctement les valeurs infinies avec Inf et -Inf :

x<-0
1/x

## [1] Inf

• ainsi que les valeurs qui ne sont pas des nombres avec NaN :

y<-1/0
y-y

## [1] NaN

• La notion exponentielle est utilisée pour les grandes valeurs :

x<- 100 * 5.3e12
x

## [1] 5.3e+14

1/x

## [1] 1.886792e-15

Créer des objets

L’opérateur d’assignation <- est une façon implicite de créer un objet ; le mode et le type de l’objet sont en effet automatiquement déterminés.

x<-2
y<-x
y

## [1] 2

Création d’un vecteur

L’opérateur d’assemblage c() est aussi une façon implicite pour créer un vecteur :

x<-c(1,3,5,7,9)
x

## [1] 1 3 5 7 9

length(x)

## [1] 5

y<-c(x,11,13)
y

## [1]  1  3  5  7  9 11 13

La création d’un vecteur pourra aussi être faite via la génération de suites. On peut aussi créer un vecteur de façon explicite en spécifiant simplement son mode et sa longueur ; la valeur des éléments du vecteur sera alors initialisée selon le mode : 0 pour numérique, FALSE pour logique, "" pour caractère.

x<-vector(mode="numeric", length=5)
x

## [1] 0 0 0 0 0

y<-vector(mode="logical", length=4)
y

## [1] FALSE FALSE FALSE FALSE

z<-vector(mode="character", length=3)
z

## [1] "" "" ""

Les éléments du vecteur seront ensuite modifiés en utilisation l’indexation.

Création d’une matrice

Une matrice est créée à 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) à 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 plutôt 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) à 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

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 être de type character ). Pour connaître les dimensions d’une matrice, on peut utiliser séparément les fonctions nrow et ncol, ou alors la fonction dim (la fonction length retourne le nombre d’éléments de la matrice) :

dim(x)

## [1] 2 3

length(x)

## [1] 6

Création d’une table de données

Un tableau de données est une collection de vecteurs de même longueur. On peut créer un tableau de données en utilisant la fonction data.frame. Par exemple :

seq1<-c(0.2,0.3,0.4,0.1)
seq2<-c(0.25,0.35,0.15,0.25)
df<-data.frame(seq1,seq2)
df

##   seq1 seq2
## 1  0.2 0.25
## 2  0.3 0.35
## 3  0.4 0.15
## 4  0.1 0.25

On peut affecter un nom de colonne particulier (différent du nom du vecteur) directement à la création du tableau de données :

toto<-c(0.25,0.25,0.4,0.1)
df<-data.frame(seq1,seq2, seq3=toto)
df

##   seq1 seq2 seq3
## 1  0.2 0.25 0.25
## 2  0.3 0.35 0.25
## 3  0.4 0.15 0.40
## 4  0.1 0.25 0.10

Il est possible de donner des noms aux lignes avec l’option row.names qui doit fournir un vecteur de mode caractère et de longueur égale au nombre de lignes du tableau de données. Par exemple, dans l’exemple ci-dessus le tableau de données correspond aux compositions en nucléotides de deux séquences, on pourrait donc écrire :

seq1<-c(0.2,0.3,0.4,0.1)
seq2<-c(0.25,0.35,0.15,0.25)
df<-data.frame(seq1,seq2,seq3=toto,row.names=c("A","C","G","T"))
df

##   seq1 seq2 seq3
## A  0.2 0.25 0.25
## C  0.3 0.35 0.25
## G  0.4 0.15 0.40
## T  0.1 0.25 0.10

On verra plus loin que la fonction read.table qui permet de lire des données dans un fichier crée implicitement un objet de type tableau de données. Les fonctions cbind et rbind que nous avons vu pour les matrices s’appliquent aussi pour des tableaux de données. On notera aussi les fonctions ncol et nrow qui renvoient le nombre de colonnes et le nombre de lignes d’un tableau de données (ou d’une matrice).

Création d’une liste

Une liste est une collection d’objets (non nécessairement de même types) ; elle se crée via la fonction list :

seq1<-c(0.2,0.3,0.4,0.1)
L1<-58402
res<-list(L1,seq1)
res

## [[1]]
## [1] 58402
## 
## [[2]]
## [1] 0.2 0.3 0.4 0.1

Le nombre d’objets contenus dans une liste s’obtient en faisant

length(res)

## [1] 2

Pour rallonger une liste d’éléments, on utilise l’opérateur d’assemblage c() :

espece1<-"phage"
c(espece1,res)

## [[1]]
## [1] "phage"
## 
## [[2]]
## [1] 58402
## 
## [[3]]
## [1] 0.2 0.3 0.4 0.1

Contrairement à data.frame, la fonction list ne conserve pas les noms des objets ; autrement dit, la longueur de la séquence (L1) est le premier élément de la liste, et la composition en nucléotides est le 2ème élément. On peut attribuer des étiquettes différentes plus explicites aux différents éléments d’une liste, ce qui sera très pratique pour y accéder (sans avoir à se souvenir dans quel ordre ils sont rangés dans la liste !). Par exemple :

seq1<-c(0.2,0.3,0.4,0.1)
L1<-58402
res<-list(longueur=L1,composition=seq1)
res

## $longueur
## [1] 58402
## 
## $composition
## [1] 0.2 0.3 0.4 0.1

On verra plus loin que pour accéder aux champs longueur (resp. composition) de la liste res, on utilisera l’opérateur $ : res$longueur (resp. res$composition).

Création d’une chaîne de caractère

Une fonction très utile pour créer une chaîne de caractère, outre l’opérateur d’assignation <-, est paste qui permet de concaténer des chaînes de caractères mais aussi des objets automatiquement convertis en chaîne de caractères. Ceci est particulièrement utile par exemple lorsque l’on veut créer un fichier de sortie dont le nom est “dynamique”. Voici quelques exemples :

nom<-paste("filename",".","txt",sep="")
nom

## [1] "filename.txt"

prefix<-"resultats."
i<-5
nom<-paste(prefix,i,".ps",sep="")
nom

## [1] "resultats.5.ps"

Par défaut sep=" " et indique le séparateur de concaténation.

Convertir un objet

On peut vouloir convertir un objet d’un type à un autre. Voici quelques exemples :

• numérique → caractère

i

## [1] 5

as.character(i)

## [1] "5"

• numérique → logique

x<-0:3
as.logical(x)

## [1] FALSE  TRUE  TRUE  TRUE

• logique → numérique

ok<-c(TRUE,FALSE,FALSE,TRUE)
as.numeric(ok)

## [1] 1 0 0 1

Lister et supprimer des objets en mémoire

Quand R est utilisé, les variables, les objets, les fonctions, … sont stockées dans la mémoire vive de l’ordinateur. On peut afficher la liste de tous les objets en mémoire en tapant la commande :

ls()

##  [1] "df"      "espece1" "i"       "L1"      "nom"     "ok"      "prefix" 
##  [8] "res"     "seq1"    "seq2"    "titre"   "toto"    "x"       "y"      
## [15] "z"

Si l’on souhaite se restreindre aux objets dont le nom contient une chaîne de caractère, il suffit de spécifier celle-ci via l’option pattern. Par exemple, si l’on veut connaître la liste des objets commençant par la lettre s, on tape :

ls(pattern="^s")

## [1] "seq1" "seq2"

La commande ls.str() va quant à elle lister tous les objets en mémoire mais aussi en donner leur détail (type, mode, valeur, etc.).

ls.str()

## df : 'data.frame':   4 obs. of  3 variables:
##  $ seq1: num  0.2 0.3 0.4 0.1
##  $ seq2: num  0.25 0.35 0.15 0.25
##  $ seq3: num  0.25 0.25 0.4 0.1
## espece1 :  chr "phage"
## i :  num 5
## L1 :  num 58402
## nom :  chr "resultats.5.ps"
## ok :  logi [1:4] TRUE FALSE FALSE TRUE
## prefix :  chr "resultats."
## res : List of 2
##  $ longueur   : num 58402
##  $ composition: num [1:4] 0.2 0.3 0.4 0.1
## seq1 :  num [1:4] 0.2 0.3 0.4 0.1
## seq2 :  num [1:4] 0.25 0.35 0.15 0.25
## titre :  chr "coucou"
## toto :  num [1:4] 0.25 0.25 0.4 0.1
## x :  int [1:4] 0 1 2 3
## y :  logi [1:4] FALSE FALSE FALSE FALSE
## z :  chr [1:3] "" "" ""

Pour effacer des objets de la mémoire, on utilise la fonction rm :

rm(x)

Si l’on veut maintenant accéder à x, le message suivant apparaît :

x

## Error in eval(expr, envir, enclos): objet 'x' introuvable

Pour effacer tous les objets de la mémoire, on tape rm(list=ls()).

Générer des données

Suites régulières

Une suite d’entiers consécutifs peut s’obtenir avec l’opérateur : ; par exemple :

5:12

## [1]  5  6  7  8  9 10 11 12

Un vecteur est ainsi crée. Cet opérateur est prioritaire sur les opérations arithmétiques :

n<-10
1:(n-2)

## [1] 1 2 3 4 5 6 7 8

1:n-2

##  [1] -1  0  1  2  3  4  5  6  7  8

La fonction rep crée un vecteur dont les éléments sont identiques ou répétés :

rep(x=1,times=10)

##  [1] 1 1 1 1 1 1 1 1 1 1

rep(x=1:5,times=3)

##  [1] 1 2 3 4 5 1 2 3 4 5 1 2 3 4 5

rep(x=1:5,each=2)

##  [1] 1 1 2 2 3 3 4 4 5 5

La fonction seq peut générer des suites régulières de nombres de deux manières différentes :

• soit en lui spécifiant, le début, la fin, puis le pas (argument by)

seq(from=2,to=20,by=2)

##  [1]  2  4  6  8 10 12 14 16 18 20

• soit en lui spécifiant le début, la fin et le nombre d’éléments (argument length)

seq(from=1,to=5,length=10)

##  [1] 1.000000 1.444444 1.888889 2.333333 2.777778 3.222222 3.666667 4.111111
##  [9] 4.555556 5.000000

Variables aléatoires

Il est très utile en statistique de pouvoir générer des variables aléatoires selon diverses lois de probabilité. R peut le faire pour un grand nombre de lois via les fonctions de la forme rfunc(n,p1,p2,...) où func indique la loi de probabilité, n est le nombre de variables à générer et p1, p2, … sont les paramètres de la loi. En voici quelques exemples :

rnorm(10)

##  [1]  0.29892803  0.74201081  0.96078574  0.19320586 -0.01408397 -0.15510241
##  [7]  1.91761619 -0.03359547 -1.49479484 -0.30150178

runif(10)

##  [1] 0.68940693 0.37510575 0.43387126 0.27174500 0.43184388 0.07910435
##  [7] 0.04746595 0.66174107 0.32610570 0.10467495

rpois(10,lambda=4)

##  [1] 2 4 3 6 2 3 4 9 7 6

• pfunc(q,p1,p2,...) : pour la probabilité cumulée jusqu’à q, – qfunc(p,p1,p2,...) : pour le quantile associé à la probabilité cumulée p, – dfunc(x,p1,p2,...) : pour la densité de probabilité en x. Cela permet ainsi de tracer des densités et de connaî̂tre la probabilité d’être supérieur ou égal à q sous une loi donnée. Si on prend l’exemple de la loi normale de moyenne 0 et de variance 1 avec q = 2.5 (cf. Figure 1), on a :

1-pnorm(2.5)

## [1] 0.006209665

Figure 1: Densité de la loi normale centrée réduite et probabilité de dépasser 2.5

Accéder aux valeurs d’un objet

L’indexation (opérateur []) permet d’accéder de façon sélective aux éléments d’un objet.

Vecteurs

Pour accéder au 2ème élément d’un vecteur x, il suffit de taper x[2]. Cela permet aussi d’aller modifier spécifiquement certains éléments :

x<-1:10
x[2]

## [1] 2

x[1]<-10
x

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

On peut aussi accéder à plusieurs éléments d’un vecteur et les modifier tous ensemble :

x<- seq(2,20,by=2)
x[1:5]

## [1]  2  4  6  8 10

x[1:5]<- rep(0,5)
x

##  [1]  0  0  0  0  0 12 14 16 18 20

La commande x[1 :5] est équivalente à x[c(1,2,3,4,5)]. On peut accéder aux éléments dont la valeur vérifie une expression de comparaison. Par exemple, aux valeurs positives d’un vecteur :

x<- runif(10,min=-1,max=1)

x>=0

##  [1]  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE FALSE

x[x>=0]

## [1] 0.3944035 0.8582654 0.9067063 0.4591849 0.8542891

On peut supprimer un ou plusieurs éléments d’un vecteur en utilisant des indices négatifs :

x<- (1:5)^2
x[-1]

## [1]  4  9 16 25

x[c(-2,-4)]

## [1]  1  9 25

Matrice

On peut accéder à un élément, à une colonne, à une ligne, à une sous-matrice d’une matrice de la façon suivante :

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

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. Pour conserver le format d’origine, ici une matrice, il suffit de spécifier l’option drop=FALSE. Par exemple :

x[,3,drop=FALSE]

##      [,1]
## [1,]    5
## [2,]    6

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ème 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

Liste

Pour accéder aux objets d’une liste on utilisera soit les crochets simples (dans ce cas une liste d’objets est retournée), soit les crochets doubles avec un unique indice (dans ce cas l’objet est extrait) :

seq1<-c(0.2,0.3,0.4,0.1)
L1<-58402
titre<-"phage"
res<-list(titre,L1,seq1)
res[1:2]

## [[1]]
## [1] "phage"
## 
## [[2]]
## [1] 58402

res[[3]]

## [1] 0.2 0.3 0.4 0.1

Si l’on a donné des étiquettes aux différents objets de la liste (pour obtenir les étiquettes d’une liste, il suffit d’utiliser la fonction ls(res)), alors on peut extraire ces objets en utilisant l’opé- rateur $ :

seq1<-c(0.2,0.3,0.4,0.1)
L1<-58402
titre<-"phage"
res<-list(espece=titre,longueur=L1,composition=seq1)
res$espece

## [1] "phage"

res$longueur

## [1] 58402

res$composition

## [1] 0.2 0.3 0.4 0.1

Tableau de données

Pour fabriquer un sous-tableau de données en sélectionnant certaines colonnes d’un tableau de données, on utilise les crochets simples :

df

##   seq1 seq2 seq3
## A  0.2 0.25 0.25
## C  0.3 0.35 0.25
## G  0.4 0.15 0.40
## T  0.1 0.25 0.10

df[1:2]

##   seq1 seq2
## A  0.2 0.25
## C  0.3 0.35
## G  0.4 0.15
## T  0.1 0.25

df[c("seq1","seq3")]

##   seq1 seq3
## A  0.2 0.25
## C  0.3 0.25
## G  0.4 0.40
## T  0.1 0.10

Si l’on veut seulement récupérer un vecteur colonne du tableau de données, on utilisera la notation matricielle df[,1] ou l’opérateur $ (df$seq1).

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 à part les opérateurs classiques, addition (+), soustraction (-), multiplication (*) et division (/), on notera les 3 autres opérateurs suivants :

• ^ : puissance
• %% : modulo
• %/% : division entière

Ces opérateurs peuvent aussi s’appliquer à des vecteurs (et à 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 même 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 à 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 com- parés et retourne donc un objet logique de même 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

Pour effectuer une comparaison globale d’objets, la fonction équivalente est identical(x,y) :

x<-seq(2,10,by=2)
y<- 2 * (1:5)
identical(x,y)

## [1] TRUE

Cette fonction (ainsi que l’opérateur ==) compare la représentation interne des données et retourne TRUE si les objets sont strictement identiques. On se méfiera ainsi des erreurs numériques dues aux calculs numériques sur ordinateur :

(1.1-0.2)==0.9

## [1] FALSE

Pour y remédier, la fonction all.equal compare l’égalité approximative, c’est-à-dire avec un seuil de tolérance (qui par défaut dépend des paramètres de la machine), entre deux objets :

all.equal(1.1-0.2,0.9)

## [1] TRUE

Opérateurs logiques

Les opérateurs logiques s’appliquent à un ou deux objets de mode logique et retournent une ou plusieurs valeurs logiques :

• !x : NON logique
• x&y : ET logique
• x|y : OU logique
• xor(x,y) : OU exclusif

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 (seule la première occurrence est considérée),
• round(x,digits=2) : arrondi de x avec un nombre de chiffres après la virgule défini par l’option digits,
• floor(x), ceiling(x) : parties entières inférieures ou supérieures de x,
• length(x) : nombre d’éléments de x,
• rev(x) : inverse l’ordre des éléments de x,
• sort(x,decreasing=F) : trie les éléments de x dans l’ordre croissant,
• choose(n,k) : combinaisons de k éléments parmi n.

Par exemple :

x<-choose(6,0:6)
x

## [1]  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

En voici d’autres à connotation statistique :

• mean(x) : moyenne des éléments de x,
• median(x) : médiane des éléments de x,
• var(x) : variance des éléments de x,
• cov(x,y) : covariance entre x et y,
• cor(x,y) : corrélation entre x et y,
• sample(x,size=n,replace=FALSE) : tirage aléatoire sans remise de n éléments parmi ceux de x.

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ème linéaire Ax = b,
• eigen(x) : calcule les valeurs et vecteurs propres de x.

Entrées et sorties

Pour les lectures et écritures de données dans des fichiers, R utilise le répertoire de travail. Il est donc nécessaire de préciser le chemin d’accès au fichier si celui-ci n’est pas dans le répertoire de travail.

mydata<-read.table(file="initiation_r_data/virus-count-tri.tab",header=TRUE, skip=1)

dim(mydata)

## [1] 65 86

colnames(mydata)

##  [1] "virus01.sq" "virus02.sq" "virus03.sq" "virus04.sq" "virus05.sq"
##  [6] "virus06.sq" "virus07.sq" "virus08.sq" "virus09.sq" "virus10.sq"
## [11] "virus11.sq" "virus12.sq" "virus13.sq" "virus14.sq" "virus15.sq"
## [16] "virus16.sq" "virus17.sq" "virus18.sq" "virus19.sq" "virus20.sq"
## [21] "virus21.sq" "virus22.sq" "virus23.sq" "virus24.sq" "virus25.sq"
## [26] "virus26.sq" "virus27.sq" "virus28.sq" "virus29.sq" "virus30.sq"
## [31] "virus31.sq" "virus32.sq" "virus33.sq" "virus34.sq" "virus35.sq"
## [36] "virus36.sq" "virus37.sq" "virus38.sq" "virus39.sq" "virus40.sq"
## [41] "virus41.sq" "virus42.sq" "virus43.sq" "virus44.sq" "virus45.sq"
## [46] "virus46.sq" "virus47.sq" "virus48.sq" "virus49.sq" "virus50.sq"
## [51] "virus51.sq" "virus52.sq" "virus53.sq" "virus54.sq" "virus55.sq"
## [56] "virus56.sq" "virus57.sq" "virus58.sq" "virus59.sq" "virus60.sq"
## [61] "virus61.sq" "virus62.sq" "virus63.sq" "virus64.sq" "virus65.sq"
## [66] "virus66.sq" "virus67.sq" "virus68.sq" "virus69.sq" "virus70.sq"
## [71] "virus71.sq" "virus72.sq" "virus73.sq" "virus74.sq" "virus75.sq"
## [76] "virus76.sq" "virus77.sq" "virus78.sq" "virus79.sq" "virus80.sq"
## [81] "virus81.sq" "virus82.sq" "virus83.sq" "virus84.sq" "virus85.sq"
## [86] "virus86.sq"

rownames(mydata)

##  [1] "long" "aaa"  "aac"  "aag"  "aat"  "aca"  "acc"  "acg"  "act"  "aga" 
## [11] "agc"  "agg"  "agt"  "ata"  "atc"  "atg"  "att"  "caa"  "cac"  "cag" 
## [21] "cat"  "cca"  "ccc"  "ccg"  "cct"  "cga"  "cgc"  "cgg"  "cgt"  "cta" 
## [31] "ctc"  "ctg"  "ctt"  "gaa"  "gac"  "gag"  "gat"  "gca"  "gcc"  "gcg" 
## [41] "gct"  "gga"  "ggc"  "ggg"  "ggt"  "gta"  "gtc"  "gtg"  "gtt"  "taa" 
## [51] "tac"  "tag"  "tat"  "tca"  "tcc"  "tcg"  "tct"  "tga"  "tgc"  "tgg" 
## [61] "tgt"  "tta"  "ttc"  "ttg"  "ttt"

mydata$virus05.sq

##  [1] 39630  1213   743   757  1175   666   410   482   635   798   374   409
## [13]   795  1129   624   639  1276   799   434   423   738   527   300   159
## [25]   467   366   162   166   537   584   530   399   867   876   358   515
## [37]   644   452   183   177   312   522   169   244   320   818   427   411
## [49]   728  1000   658   682  1111   749   560   414   966   706   418   436
## [61]   732   920  1108   843  1574

colnames(mydata)<-paste(sep="", "virus",1:86)

myshortdata<-scan("initiation_r_data/short-virus.tab",what=list(0,0,0),skip=1)
myshortdata

## [[1]]
##  [1] 23814   728   453   588   732   431   234   141   485   571
## 
## [[2]]
##  [1] 20869   760   422   553   503   544   223   145   396   726
## 
## [[3]]
##  [1] 31787   833   531   463  1087   695   294   310   836   390

myshortdata<-scan("initiation_r_data/short-virus.tab",what=list(seq1=0,seq2=0,seq3=0),skip=1)
myshortdata

## $seq1
##  [1] 23814   728   453   588   732   431   234   141   485   571
## 
## $seq2
##  [1] 20869   760   422   553   503   544   223   145   396   726
## 
## $seq3
##  [1] 31787   833   531   463  1087   695   294   310   836   390

Afficher des résultats

Affichage à l’écran

On a vu que la façon la plus simple d’afficher le contenu d’un objet à l’écran était de taper son nom suivi de la touche “Entrée”. C’est équivalent à écrire explicitement print(x) :

x<-choose(6,0:6)
print(x)

## [1]  1  6 15 20 15  6  1

On utilisera print(x) à l’intérieur d’une boucle, d’une fonction ou d’un programme. Si l’on veut un “bel” affichage, on peut alors utiliser la fonction cat qui va convertir le contenu des objets en chaî̂ne de caractères (donc sous la forme d’un vecteur), concaténer autant de chaînes de caractères que demandées et imprimer la chaîne résultante :

x<-choose(6,0:6)
cat("Les combinaisons parmi 6 elements sont : ",x,"\n")

## Les combinaisons parmi 6 elements sont :  1 6 15 20 15 6 1

La chaîne de caractères "\n" signifie un retour à la ligne. Par défaut, la concaténation des chaînes de caractères se fait avec le séparateur sep=" ". La fonction cat est donc particulièrement adaptée à l’affichage de vecteurs (éventuellement de longueur 1). Pour afficher un tableau (matrice ou tableau de données) on utilisera print.

Affichage dans un fichier

Si l’on veut imprimer des résultats dans un fichier, on peut procéder de deux manières :

• Soit rediriger la sortie standard (c’est-à-dire la console) dans un fichier via la fonction sink(file="file.res", append=TRUE) avant d’afficher ; si l’option append n’est pas spécifiée (FALSE par défaut), l’écriture écrase l’ancien contenu du fichier. Ne pas oublier de rebasculer la sortie standard après écriture en faisant sink().

sink("toto")
cat("Combinaisons parmi 6 elements : \n")
print(x)
sink()

Le fichier toto a été créé et contient :

Combinaisons parmi 6 elements :
[1] 1 6 15 20 15 6 1

• Soit en utilisant l’option file (et append) de la fonction cat.

cat(file="toto","x=",x,append=TRUE)

Le fichier toto contient maintenant :

Combinaisons parmi 6 elements :
[1] 1 6 15 20 15 6 1
x= 1 6 15 20 15 6 1

Si l’on veut plutôt écrire le contenu d’un objet, plus précisément un tableau de données ou une matrice, dans un fichier (pour former un nouveau fichier de données par exemple), on pourra utiliser la fonction write.table. Celle-ci stocke l’objet sous la forme d’un tableau de données et le fichier créé pourra alors être relu avec read.table. Par exemple, le fichier short-virus.tab qui a été utilisé précédemment a été obtenu de la façon suivante à partir du tableau de données mydata :

write.table(mydata[1:10,1:3],file="short-virus.tab",row.names=FALSE,quote=FALSE)

L’option row.names indique si le nom des lignes doit être écrit dans le fichier (col.names pour les colonnes), tandis que l’option quote indique si les chaînes de caractères sont écrites avec leurs guillemets.

Sauvegarder des données

La sauvegarde des données n’est pas automatique, toutefois, on a la possibilité de sauvegarder l’ensemble des objets en mémoire avant de quitter une session R. Pour cela, il suffit de répondre ’y’ à la question posée suite à la commande q() : ”Save workspace image ? [y/n/c]”. Les objets sont alors sauvegardés dans le répertoire .RData du répertoire de travail et seront disponibles lors de la prochaine session R. On peut néanmoins sauvegarder explicitement des objets R dans un fichier en utilisant la fonction save(mydata,file="mydata.Rdata") (à noter : le fichier mydata.Rdata n’est pas lisible à l’oeil). Pour recharger l’objet enregistré lors d’une nouvelle session, il suffira de faire load("mydata.Rdata").

Boucles

Boucle for

La boucle for est utilisée pour répéter une suite d’instructions un nombre prédéfini de fois. La syntaxe standard est la suivante :

for (compteur in suite) {
  instructions
}

Les accolades ne sont pas nécessaires s’il n’y a qu’une instruction. Voici un exemple ; pour calculer la quantité \(\sum_{i = 1}^{10} i^2\), on effectuera

somme<-0
for (i in 1:10){
somme <- somme + i^2
}
somme

## [1] 385

Boucle while

La boucle while est utilisée pour répéter une suite d’instructions tant qu’une condition est vraie. La syntaxe standard est la suivante :

while (condition) {
  instructions
}

Voici un exemple ; on souhaite trouver le plus grand entier dont le carré est strictement plus petit que 999 :

entier<-0
while ( (entier+1)^2 < 999 ){
entier <- entier + 1
}
entier

## [1] 31

Tests

Un test si alors permet d’exécuter des instructions seulement si une condition est réalisée, tandis qu’un test si alors sinon permet d’exécuter des instructions différentes selon qu’une condition est vraie ou fausse. La syntaxe standard est la suivante :

if (condition) {
  instructions
}else{
  instructions
}

Voici un exemple :

x<-rpois(1,20)
if (x%%2==0){
  pair<-TRUE
}else{
  pair<-FALSE
}
x

## [1] 16

pair

## [1] TRUE

L’instruction sinon n’est pas obligatoire mais si elle existe alors le mot-clé else doit être sur la même ligne que l’accolade fermante du si. On peut imbriquer plusieurs boucles si alors sinon si alors sinon etc.

Vectorisation

Comme on l’a déjà vu, un gros avantage de R est sa capacité à travailler vectoriellement ce qui évite d’avoir à programmer des boucles for et/ou des tests. Ainsi, la boucle for vue précédemment peut être remplacée simplement par

x<-1:10
y<-x^2

tandis que la boucle suivante :

n<-10
x<-rpois(n,20)
pair<-rep(FALSE,n)
for (i in 1:n){
  if (x[i]%%2==0) pair[i]<-TRUE
}

peut s’écrire simplement

pair[x%%2==0]<-TRUE

Plus généralement, toute fonction (de R ou créée par l’utilisateur) peut être appliquée à tous les éléments d’une matrice (ou seulement à certaines lignes ou colonnes), d’un vecteur ou d’une liste. Pour cela on utilise les fonctions apply, sapply ou lapply.

Écrire une fonction

L’essentiel du travail sous R se fait à l’aide de fonctions dont les arguments sont indiqués entre parenthèses. Outre les fonctions déjà implémentées dans R (on en a déjà vu un certain nombre), l’utilisateur peut écrire ses propres fonctions (c’est même d’ailleurs conseillé !) afin de pouvoir efficacement répéter certaines opérations. La syntaxe standard est la suivante :

function name<-function(arg1, arg2,. . ., argn) {
  instructions
  return(result)
}

Voici par exemple l’écriture de la fonction zscore qui prend 3 arguments, une observation obs (éventuellement plusieurs sous la forme d’un vecteur), une moyenne exp (éventuellement un vecteur) et une variance var (éventuellement un vecteur), et retourne le z-score associé c’est-à-dire \((obs - exp)\sqrt{var}\) :

zscore<-function(obs,exp,var)
{
res<- (obs-exp)/sqrt(var)
return(res)
}

Pour pouvoir exécuter cette fonction, il faut la charger en mémoire, soit en tapant chacune des lignes au clavier soit en l’écrivant dans un fichier et en “compilant” ce dernier avec la fonction source, comme pour un programme (paragraphe suivant). Dès que la fonction est chargée, on l’utilise naturellement :

x<-c(3,5)
xmoyenne<-c(2.5,4.8)
xvariance<-c(0.7,0.9)
score<-zscore(obs=x,exp=xmoyenne,var=xvariance)
score

## [1] 0.5976143 0.2108185

Dans cet appel à la fonction zscore, le nom des arguments (obs, exp et var) a été utilisé (fortement recommandé) ce qui permet par exemple de passer leur valeur dans le désordre. On peut ommettre le nom des arguments, en appelant alors zscore(x,xmoyenne,xvariance), mais dans ce cas il faut absolument respecter l’ordre des arguments.

Les variables définies dans les fonctions (res dans la fonction zscore par exemple) sont considérées comme des variables locales. Si ces variables existaient déjà dans l’environnement “extérieur” à la fonction alors leur contenu n’est pas modifié. Si elles n’existaient pas, alors elles n’existeront pas plus après l’appel à la fonction. Par contre, si la fonction utilise une variable non définie dans la fonction, alors R va la chercher dans l’environnement extérieur ; si elle existe, R utilise sa valeur, sinon un message d’erreur est donné.

Le code des fonctions créées et chargées en mémoire s’obtient simplement en tapant le nom de la fonction suivi de “entrée”.

Écrire un programme

On écrira typiquement un programme R dans un fichier texte ayant l’extension ’.r’, par exemple myprog.r. Si le programme définit des fonctions et les utilise, il convient de les définir avant de les utiliser (par exemple en tête du fichier, éventuellement après l’assignation des variables globales). Le caractère ’#’ sert à ajouter des commentaires : en effet, R passe à la ligne suivante. Pour exécuter le programme contenu dans le fichier myprog.r, il suffit de taper

source("myprog.r")

Nuage de points

Nous allons nous mettre ici dans le cas où nous avons un certain nombre de points à représenter en dimension 2, c’est-à-dire que chaque point a une abscisse et une ordonnée. En d’autres termes, nous disposons d’un vecteur d’abscisses (x) et un vecteur d’ordonnées associées (y). L’exemple sur lequel nous allons travailler va être le suivant : les points correspondent à des trinucléotides, leur abscisse (resp. ordonnée) est leur comptage dans la première (seconde) séquence du tableau de données mydata :

x<-mydata[-1,1]
y<-mydata[-1,2]
length(x)

## [1] 64

length(y)

## [1] 64

Le graphique de base (cf. Figure 2) s’obtient alors en faisant :

plot(x,y)

Figure 2: La fonction plot(x,y) sans options

Nous allons modifier ce graphique en jouant sur plusieurs options.

• xlim, ylim fixent les limites inférieures et supérieures des axes (vecteurs à deux éléments),
• xlab, ylab permettent de spécifier la légende des axes (mode caractère),
• main permet de mettre un titre au dessus du graphique (mode caractère),
• pch définit le symbole représentant les points : soit un entier de 1 à 25, soit n’importe quel caractère entre guillemets,
• col spécifie la couleur des symboles ("blue","red" etc. la liste des couleurs est disponible avec colors() tandis que rainbow(n) retourne un vecteur de n couleurs régulièrement réparties dans l’arc-en-ciel) ; on peut aussi jouer sur la couleur du titre (col.main), des labels des axes (col.lab) et de la graduation des axes (col.axis),
• bty contrôle la forme du cadre : carré par défaut (“o”), en L (“l”), en U (“u”), en C (“c”), en 7 (“7”) ou en crochet (“]”).

Par exemple, la Figure 3 a été obtenue par :

plot(x,y,xlab="Sequence 1",ylab="Sequence 2",main="Comptage des trinucleotides", xlim=c(0,1200),ylim=c(0,1200),pch=18,col="blue",bty="l")

Figure 3: La fonction plot avec les options xlab, ylab, main, xlim, ylim, pch, bty et col

On verra plus loin comment rajouter des éléments graphiques sur cette figure : axes, droites, texte, légende etc.

On peut jouer sur la taille des symboles grâce à l’option cex. Par défaut cex=1 ; on peut lui fournir un nombre positif qui représente un coefficient multiplicatif par rapport à la taille par défaut (une valeur entre 0 et 1 pour réduire la taille, ou plus grande que 1 pour au contraire l’augmenter). De la même façon les options cex.axis, cex.lab et cex.main contrôlent la taille des graduations des axes, des labels des axes et du titre.

Pour changer le style du texte, on utilise l’option font qui se décline aussi sous les formes font.axis, font.lab et font.main, (1 pour normal, 2 pour gras, 3 pour italique et 4 pour gras italique).

Pour utiliser une échelle logarithmique, on utilisera l’option log qui vaudra soit "x", soit "y", soit "xy".

Courbe

Pour dessiner une “courbe”, on utilise aussi la fonction plot à la “seule” différence que l’on souhaite relier les points entre eux. Pour cela l’option principale est type qui vaudra soit "b" si l’on veut des points connectés par une ligne soit "l" si l’on veut seulement une ligne (par défaut type="p").

Comme exemple, nous allons tracer la densité de la loi normale de moyenne 0 et de variance 1 entre -3 et 3 (cf. Figure 4) :

t<-seq(-3,3,by=0.2)
plot(t,dnorm(t,mean=0,sd=1),type="l",col="red",main="densite N(0,1)",font.main=4)

Figure 4: La fonction plot avec type=“l”

Pour cet exemple, on aurait pu utiliser la fonction curve qui trace la courbe de fonctions de type \(f(x)\) pour lequel R a accès aux valeurs pour tout \(x\). On peut jouer sur le type de ligne à l’aide de l’option lty. Par défaut lty=1 ce qui donne des lignes continues, mais on peut obtenir des tirets (lty=2), des pointillés (lty=3), une alternance de points et tirets (lty=4), des tirets longs (lty=5) ou une alternance de tirets courts et longs (lty=6). On peut aussi jouer sur l’épaisseur des lignes à l’aide de l’option lwd qui vaut 1 par défaut.

Analyse en Composantes Principales (ACP)

L’analyse en composantes principales ou ACP, donne une représentation synthétique, numérique ou graphique, des données. Cette méthode est particulièrement intéressante lorsqu’on dispose d’un nuage de points dans un espace de dimension élevée, c’est-à-dire qu’à chaque observation correspond un grand nombre de variables. L’ACP va conduire à un sous-espace de plus petite dimension, tel que la projection sur ce sous-espace retienne la majeure partie de l’information.

L’ACP s’utilise avec des données quantitatives. Les données sont structurées en lignes, associées aux individus (individu ≡ unité observable), et en colonnes, associées aux variables qui décrivent les individus. Les lignes sont généralement indicées par i, i ∈ {1, …, n} et les colonnes par j, j ∈ {1, …, p}. Si l’on appelle X ce tableau de données, l’élément (i, j) de X, noté x i,j , est égal à la valeur prise par la variable j pour l’individu i. Le principe de l’ACP est d’établir une nouvelle base orthonormée dans laquelle les axes (appelés composantes) sont construits séquentiellement de façon à absorber une quantité maximale de variance. Les nouveaux axes sont ainsi ordonnés, le premier axe portant la plus grande part de la variabilité et le dernier axe portant la plus faible part. L’ACP nécessite une phase de préparation des données qui doivent être centrées. Les variables seront aussi réduites si l’on veut qu’elles aient toutes la même influence dans l’analyse. La fonction scale() permet de centrer et/ou réduire les données en colonnes (à noter : par défaut center et scale valent TRUE) : scale(x, center = TRUE, scale = TRUE). Dans les fonctionnalités chargées par défaut avec R (package stats), 2 fonctions sont disponibles pour réaliser une ACP : princomp() et prcomp().

princomp() calcule les valeurs propres sur la matrice de covariance ou de corrélation alors que prcomp() utilise la décomposition en valeurs singulières ; prcomp est une généralisation de la méthode princomp.

Pour illustrer l’ACP, nous allons sélectionner un sous-ensemble du jeu de données Y :

indd1 <- c(3,4,6,7,9,12,16,21,22,30,31,37,39,44,46,47,53,54,60,66,70,81,82)
mots1 <- c("aaa","agg","cgt","tgt","ttt")
Y1 <- Y[indd1,mots1]
dim(Y1)

## [1] 23  5

Sur ce sous-ensemble, noté Y1, nous allons appliquer une ACP en utilisant la fonction prcomp qui possède les options center et scale fixées respectivement à TRUE et FALSE par défaut. Ici, nous avons choisi de normaliser les données, aussi nous modifions l’option scale :

Y1.prcomp <- prcomp(Y1,scale=T)

Nous utilisons ensuite la fonction summary() qui résume les résultats d’une analyse. Cette fonction reconnaı̂t le type d’objet qu’on lui attribue et applique sur l’objet la fonction summary spécifique à cet objet.

summary(Y1.prcomp)

## Importance of components:
##                           PC1    PC2     PC3     PC4     PC5
## Standard deviation     1.6230 1.3900 0.56236 0.30439 0.15789
## Proportion of Variance 0.5268 0.3864 0.06325 0.01853 0.00499
## Cumulative Proportion  0.5268 0.9132 0.97648 0.99501 1.00000

La variabilité totale est représentée par la surface de l’histogramme (Figure 9). Le but de l’analyse étant de conserver le maximum de variabilité avec le minimum de composantes, on observe la décroissance de la variance sur les différentes composantes et on cherche une rupture de la pente. Ainsi, on remarque sur la Figure 9 une rupture de la pente entre la deuxième et la troisième composante. En se rapportant aux valeurs de proportions de variance cumulées, on voit que les deux premières composantes portent 91,3% de la variance. On peut donc choisir de réduire l’espace à ces 2 premières composantes.

La représentation sous forme de biplot (Figure 10) permet de visualiser la proximité entre les individus. Elle permet également d’apprécier les corrélations entre les variables. Par défaut, le nuage est projeté sur les deux premiers axes principaux, mais on peut spécifier explicitement les axes en utilisant l’option choices=c(1,2) (valeur par défaut).

plot(Y1.prcomp)

Figure 9: Variance portée par chacune des composantes

biplot(Y1.prcomp)

Figure 10: Biplot issu des 2 premières composantes de l’ACP

Classification

L’objectif de la classification est de regrouper les objets similaires parmi un ensemble d’objets dont les caractéristiques sont connues. La similarité des objets est appréciée en calculant leurs distances. Plusieurs distances sont disponibles dans R. Il existe aussi plusieurs façons de regrouper les objets : soit par un processus hiérarchique, ascendant ou descendant, soit sur la base du “partitionnement” à partir d’un nombre prédéfini de classes. Dans R, il existe la bibliothèque cluster qui propose plusieurs méthodes de classification adaptées à différents types de données. Par exemple, la fonction agnes() permet de réaliser une classification hiérarchique ascendante : à chaque étape du processus les deux objets ou classes les plus proches sont fusionnés pour former une nouvelle classe, et les distances de cette nouvelle classe à tous les autres, objets ou classes, sont recalculées.

library(cluster)
agnes(Y1)

## Call:     agnes(x = Y1) 
## Agglomerative coefficient:  0.8894554 
## Order of objects:
##  [1] 3  16 4  7  6  9  37 12 44 39 46 47 21 60 82 81 22 31 53 54 30 66 70
## Height (summary):
##     Min.  1st Qu.   Median     Mean  3rd Qu.     Max. 
## 0.001691 0.003807 0.006542 0.012209 0.014176 0.056257 
## 
## Available components:
## [1] "order"     "height"    "ac"        "merge"     "diss"      "call"     
## [7] "method"    "order.lab" "data"

La fonction agnes retourne une liste composée de plusieurs champs, en particulier, le coefficient d’agglomération (ac) qui est une mesure de force de la “structure en classes”. Cette mesure est calculée de la façon suivante : soit d(i) la hauteur de la première fusion de chaque objet et soit h la hauteur de la dernière fusion, le coefficient d’agglomération s’écrit alors comme la moyenne des (1 − d(i)/h). Une valeur proche de 1 du coefficient d’agglomération signifie que les objets sont fortement structurés en classes. Une valeur proche de 0 signifie que les objets appartiennent tous à une même classe.

Le champ “merge” liste les étapes de fusion. Les chiffres affectés du signe “-” correspondent aux objets de départ. Les chiffres sans signes sont les numéros des classes attribués au fur et à mesure qu’elles sont construites.

Le champ “height” est le vecteur des hauteurs de fusion.

Tous les champs peuvent être extraits à l’aide du $. Par exemple :

agnes(Y1)$height

##  [1] 0.007256906 0.011765932 0.001708030 0.003026567 0.022953801 0.014979353
##  [7] 0.034979462 0.001872430 0.003747635 0.005237884 0.001691141 0.029214443
## [13] 0.005472515 0.003984952 0.005827433 0.011098483 0.008916999 0.005466319
## [19] 0.003279229 0.018711126 0.056256535 0.011160517

Deux types de graphiques sont proposés pour afficher les résultats de la fonction agnes :

• la bannière, qui s’obtient avec la fonction bannerplot() et qui reproduit les hauteurs des différentes fusions dans l’ordre de sortie des objets ;
• l’arbre de classification qui s’obtient avec la fonction pltree() et qui permet une vue synthétique des regroupements et le repérage d’éventuelles classes.

Nous avons représenté sous forme de bannière (Figure 11) puis d’arbre (Figure 12) les résultats de la classification des séquences de Y1.

La classification peut être réalisée à partir des corrélations. Par exemple, les Figures 13 et 14 montrent l’arbre de classification établi pour les séquences de Y1 et celui établi pour les variables de Y, tous deux réalisés à partir des corrélations.

bannerplot(agnes(Y1),main="",sub="")

Figure 11: Bannière de Y1

pltree(agnes(Y1))

Figure 12: Arbre de classification des séquences de Y1

pltree(agnes(cor(t(Y1))))

Figure 13: CHA des séquences de Y1 à partir des corrélations

pltree(agnes(cor(Y[,-c(1,2)])))

Figure 14: CHA des variables de Y à partir des corrélations