22 janvier 2021

Mises à jour et compléments :

Département de Management des Organisations — Université de Thiès

Table des matières

1 Introduction à R 3
1.1 Données utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Installation de R et RStudio . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Installation de R . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Installation de RStudio . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.3 Comment executer un code . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Architecture de R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4 Utilisation de packages existants . . . . . . . . . . . . . . . . . . . . . . . 5
1.4.1 A propos de l’aide . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Emplacement des packages . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 Information sur les packages . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2 Notions de base 8
2.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Créer un document RMarkdown . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Les commandes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4.1 Caractères spéciaux : . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4.2 Les entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Les objets dans R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5.1 Les commandes de base . . . . . . . . . . . . . . . . . . . . . . . 10
2.5.2 Classes et attributs . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.5.3 Les valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . 10
2.6 Créer et manipuler des objets . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6.1 Les structures de base . . . . . . . . . . . . . . . . . . . . . . . . 11
2.6.2 Les nombres et les vecteurs . . . . . . . . . . . . . . . . . . . . . 11
2.6.3 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6.4 Les facteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6.5 Matrices et tableaux . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6.6 Les arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.7 Tables de données . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.8 Tables statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6.9 Les ts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.6.10 Notion d’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

1
 2.7 Lire et enregistrer des données dans un fichier . . . . . . . . . . . . . . . . 28
2.7.1 Lire des données . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.7.2 Le package data.table . . . . . . . . . . . . . . . . . . . . . . . . 28
2.7.3 Enregistrer des données . . . . . . . . . . . . . . . . . . . . . . . 29
2.7.4 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.7.5 Solution de l’exercice . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.8 Statistique descriptive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.8.1 Indicateurs statistiques . . . . . . . . . . . . . . . . . . . . . . . . 30
2.8.2 Quantiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.8.3 Résumés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.8.4 Statistiques bidimensionnelles . . . . . . . . . . . . . . . . . . . . 33
2.9 Les graphiques avec R . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.9.1 Les principales commandes graphiques . . . . . . . . . . . . . . . 35
2.10 Graphiques statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.10.1 Diagramme en bâtons . . . . . . . . . . . . . . . . . . . . . . . . 38
2.10.2 Diagrammes circulaires . . . . . . . . . . . . . . . . . . . . . . . 40
2.10.3 Diagrammes à moustaches . . . . . . . . . . . . . . . . . . . . . . 42
2.10.4 Histogrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2.10.5 Diagrammes matriciels . . . . . . . . . . . . . . . . . . . . . . . . 46

3 Tests paramétriques et non paramétriques 47

3.1 Modèle linéaire multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.1.1 Rappels théoriques . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4 Analyse de la variance à un facteur 51

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.1.1 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.1.2 Exemple : Rendement et variété de maïs, quel problème ? . . . . . . 51
4.2 Modélisation statistique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.2.1 Définitions et notations . . . . . . . . . . . . . . . . . . . . . . . . 52
4.2.2 Modèle statistique . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.2.3 Conditions fondamentales . . . . . . . . . . . . . . . . . . . . . . 54
4.3 Test de comparaison de plusieurs espérances . . . . . . . . . . . . . . . . . 54
4.3.1 Deux propriétés fondamentales . . . . . . . . . . . . . . . . . . . . 55
4.3.2 Le résultat fondamental de l’analyse de la variance . . . . . . . . . 55
4.3.3 Test de l’analyse de la variance . . . . . . . . . . . . . . . . . . . . 56
4.3.4 Tableau de l’analyse de la variance . . . . . . . . . . . . . . . . . . 57
4.4 Vérification des trois conditions fondamentales et conclusion . . . . . . . . 58
4.4.1 Condition d’indépendance . . . . . . . . . . . . . . . . . . . . . . 58
4.4.2 Condition de normalité . . . . . . . . . . . . . . . . . . . . . . . . 58
4.4.3 Conditions d’homogénéité des variances . . . . . . . . . . . . . . . 59
4.4.4 Et si les conditions ne sont pas vérifiées que faire ? . . . . . . . . . 61
4.4.5 Conclusion de l’analyse de la variance . . . . . . . . . . . . . . . . 61

2
Chapitre 1

Introduction à R

Ce chapitre propose une présentation du logiciel R.

R est à la fois un outil et un langage dédié au traitement des données statistiques (calculs,
modélisation, production de graphiques). Il appartient à la famille des logiciels de calcul
numérique par opposition aux logiciels de calcul symbolique. Il est né au début des années
1990 à l’initiative de deux professeurs de l’Université d’Auckland en Nouvelle-Zélande,
Ross Ihaka et Robert Gentleman, qui s’étaient fixés comme objectif de créer un outil basé
sur le langage de programmation Scheme et inspiré du nouveau langage statistique S proposé
par Rick Becker, John Chambers et A. Wilks des Bell laboratories.
Depuis une dizaine d’années, R a atteint une maturité suffisante pour devenir un outil
statistique de premier plan utilisé dans le domaine de l’enseignement et de la recherche aussi
bien que dans les milieux professionnels. Cela est dû au fait qu’il s’agit d’un logiciel gratuit,
que son code source est public et modifiable et que le travail de développement reste très
actif.
R est conçu comme un outil extensible : son langage et son architecture interne rendent
possible l’adjonction d’extensions et une bibliothèque considérable s’est développée pour
définir des ressources et des procédures relevant de domaines très variés. Chacun peut aisé-
ment créer ses propres extensions pour effectuer des tâches particulières.

1.1 Données utilisées

Les statistiques se fondent sur des données observées. Ces données sont collectées sous
des formes diverses et mises en forme dans des structures adaptées au traitement par les ordi-
nateurs et les logiciels de calcul numérique. C’est ce qu’on appelle des jeux de données (en
anglais datasets). Le logiciel R fournit plus de quatre vingt jeux de données créés à des fins
pédagogiques pour que chacun puisse s’exercer et puisse tester les diverses fonctionnalités.

3
1.2 Installation de R et RStudio
1.2.1 Installation de R
R est un logiciel open source et gratuit. Son code source est public : il est accessible à tout
le monde et peut être modifié. Il est diffusé selon le principe de licence GNU et accessible :
http ://cran.r-project.org.
Sur cette page, on trouve une section appelée Download qui comporte un lien vers le site
de téléchargement appelé CRAN (Comprehensive R Archive Network ). L’installation de R
varie selon le système d’exploitation (Windows, Mac OS X ou Linux) mais les fonctionnali-
tés sont les mêmes et les programmes sont portables d’un système à l’autre.
Il existe des sites miroirs du CRAN dans de nombreux pays. En particulier en France,
voici trois miroirs actuellement disponibles :
— http ://cran.univ-lyon1.fr/ hébergé par le département de Biométrie de l’Université
de Lyon ;
— http ://mirror.ibcp.fr/pub/CRAN/ hébergé par l’institut de Biologie et de Chimie des
protéines (IBCP) de Lyon ;
— http ://ftp.igh.cnrs.fr/pub/CRAN/ hébérgé par l’institut de Génétique humaine de Mont-
pellier.

1.2.2 Installation de RStudio

L’utilisation d’un environnement de développement intégré (IDE) facilite l’utilisation du
logiciel R. Nous utilisons dans ce cours l’environnement RStudio. Son installation suppose
au préalable l’installation de R et se fait avec le lien (https ://www.rstudio.com).
L’environnemnt de RStudio se présente sous la forme d’une fenêtre globale scindée en
4 sous-fenêtres distinctes :
— la fenêtre de scripts (en haut à gauche),
— la console (en bas à gauche),
— la fenêtre d’environnement et d’historique (en haaut à droite),
— la fenêtre des fichiers, graphes, packages et d’aide (en bas à droite).
RStudio permet d’écrire des notebooks combinant de manière interactive du code R, du
texte mis en forme en Markdown et des appels à du code Python ou Bash.

1.2.3 Comment executer un code

Pour exécuter du code R écrit dans la fenêtre de scripts, on appuie sur le bouton Run. Le
code s’affiche dans la console R avec un prompt de la forme : >.
Quand R attend la suite d’une instruction, l’invite de commande devient : +.

1.3 Architecture de R
Le logiciel R est entièrement modulaire. Le programme R est construit autour d’un noyau
central qui définit principalement un analyseur syntaxique (appelé parser en anglais) et un
interpréteur de commandes. Il comporte aussi la définition de quelques commandes de base

4
dites primitives. R est en effet un ensemble de commandes servant à exécuter des tâches
statistiques : l’interpréteur du noyau sert principalement à comprendre et à exécuter les com-
mandes.
Autour du noyau central qui assure le fonctionnement de l’ensemble, les fonctionnali-
tés sont définies dans des modules extérieurs appelés des packages qui sont chargés à la
demande.
Ces packages contiennent de nouvelles fonctions et des jeux de données. Nous expli-
quons ci-dessous l’utilisation de base des packages : comment les charger et comment en
installer de nouveaux.

1.4 Utilisation de packages existants

Les packages sont chargés en mémoire au moyen des commandes library ou require.
On y indique, en premier argument, le nom du package à charger.
library() Visualiser tous les packages disponibles.
L’instruction suivante, par exemple, permet de charger un classique, le package MASS
(Modern Applied Statistics with S ) :
> library(MASS)
La fonction require est plutôt destinée à être utilisée dans du code, par exemple depuis la
définition d’autres fonctions qui requièrent la présence d’un package particulier. Elle renvoie
une valeur logique (TRUE ou FALSE) qui permet de tester si le chargement du package a
réussi ou échoué. L’instruction précédente peut être remplacée par celle-ci :
> require(MASS)

1.4.1 A propos de l’aide

On peut obtenir de l’aide concernant le contenu d’un package en utilisant l’argument
optionnel help. Par exemple :
> library(help="MASS")
help.start() Ouvrir l’aide dans netscape. Visiter les Packages
est souvent d’une très grande utilité.
help("lm") Afficher les détails de l’aide sur la fonction "lm".
help.search("lm") Rechercher la fonction "lm" dans les packages R.

1.5 Emplacement des packages

Les packages peuvent être installés dans différents emplacements : au niveau de la ma-
chine pour les rendre disponibles à tous les utilisateurs ou au niveau de chaque utilisateur.
Ces emplacements sont désignés sous le nom de bibliothèques locales.
La fonction .libPaths utilisée sans argument, permet de connaître l’emplacement des
bibliothèques locales : c’est un vecteur comportant les chemins d’accès des répertoires qui
contiennent des packages pour R.

5
 La fonction .libPaths peut aussi être utilisée pour définir un nouvel emplacement :

.libPaths("/home/xxx/R/local/library")

Il existe, d’autre part, deux variables globales définissant des chemins d’accès :

1.6 Information sur les packages

Pour installer un nouveau package, par exemple gee, on téléchargera dans un premier
temps le fichier gee 4.13-6.tar.gz disponible sur le site web du CRAN. On tapera ensuite
à partir du sytème (et non de R) la commande R INSTALL gee 4.13-6.tar.gz. Il est utile de
vérifier régulièrement les versions des packages installés en comparaison à celles disponibles
sur CRAN à l’aide de la commande update.packages().
Pour obtenir la liste des packages chargés en mémoire, on utilise la fonction .packages.
Pour afficher son contenu :

> (.packages())

Sous cette forme, la fonction indique seulement les packages installés sur la machine. Il faut
ajouter l’argument all qui prend une valeur logique (TRUE ou FALSE) :

.packages(all=TRUE)
Nom Description
base fonctions de base
compiler génération de code machine
datasets jeux de données classiques
graphics fonctions graphiques simples
stats fonctions statistiques ordinaires

1.7 Objectifs
Savoir :
— se servir de l’aide en ligne de R ;
— manipuler les objets de base de R : vecteur, matrice, liste, data.frame ;
— programmer une fonction élémentaire.

Pour plus d’informations, on renvoie aux références suivantes :

1. Pierre-André Cornillon et autres (2018). R pour la statistique et la science des don-
nées. Presses Universitaires de Rennes.
2. Bernard Desgraupes (2013). Le livre de R Apprentissage et référence. Vuibert.
3. Pierre-André Cornillon et autres (2008). Statistique avec R. Presses Universitaires de
Rennes.
4. Frédéric Bertrand et Myriam Maumy-Bertrand (2014). Initiation à la Statistique avec
R. 2e édition. Campus LMD, Dunod

6
De nombreux tutoriels sont accessibles en ligne, comme par exemples :
Venables W. and Smith D. An introduction to R. Distribué avec R.
Paradis E. R pour les débutants.
http://edutechwiki.unige.ch/fr/Tutoriels_R
https://larmarange.github.io/analyse-R/analyse-R.pdf

7
Chapitre 2

Notions de base

2.1 Prise en main

2.2 Environnement de travail
— Pour connaître le répertoire de travail, on utilise la commande getwd().
— Pour modifier ce répertoire, on utilise setwd("/home/etudiant/R").
— Pour afficher la liste des fichiers du répertoire courant, on utilise list.files().
On peut de manière équivalente cliquer dans la fenêtre RStudio en bas à droite sur l’on-
glet Files, puis sélectionner son répertoire de travail, appuyer sur le bouton More et cliquer
sur Set as Working Directory.
Script : quand on écrit un script, on le sauvegarde régulièrement dans son répertoire de
travail en cliquant sur File puis Save, ou sur la disquette. Le script est sauvegardé dans un
fichier dont l’extension est .R.
Environnement : par défaut, R conserve en mémoire les objets (variables, tableaux de
résultats, etc). On retrouve tous ces objets dans la fenêtre environnement (en haut à droite).
Ils peuvent être sauvegradés dans une image de la session nommée .RData, grâce à la com-
mande save.image() ou en quittant. Les objets ainsi sauvegardés seront disponible pour une
session future à l’aide de la fonction load ou en allant dans la fenêtre en bas à droite, dans
l’onglet Files et en cliquant sur le fichier .RData.
Une alternative à l’ensemble de ces étapes (spécification du répertoire de travail, sauve-
garde du script .R, de l’image .RData et des résultats) consiste à créer un projet RStudio
en cliquant sur File puis New Project...,New Directory et enfin Project. Un fichier avec
l’extension .Rproj est créé et en cliquant dessus, on réouvrira tout le projet.

2.3 Créer un document RMarkdown

Pour créer un document contenant le code, les résultats de l’exécution du code (comme
des sorties numériques ou graphiques) et les commentaires on utilise l’outil RMarkdown.
Accès : Dans RStudio, à partir de l’icône File, sélectionner New File puis R Mark-
down.
Il

8
2.4 Les commandes de base
R Appeller R. > s’affiche, indiquant que R est prêt à
fonctionner.
q() Quitter R. Save workspace image ? [y/n/c] s’affiche
−→ Sauvegarder ou non l’espace de travail.
INTERRUPT (e.g. C-c ou esc) Arrêter la commande en cours.

2.4.1 Caractères spéciaux :

" ;" permet de séparer des commandes sur une même ligne, "]" permet de mettre des
commentaires, "\n" permet d’aller á la ligne dans une chaîne de caractères, "\t" produit une
tabulation.
Les flèches au clavier permettent de rappeler des commandes.

2.4.2 Les entrées/sorties

source("mescommandes.txt")
sink("messorties.txt")
sink()
Exécuter les commandes contenues dans le fi-
chier "mescommandes. txt"
Rediriger les sorties vers le fichier "messor-
ties.txt".
Arrêter la redirection.

2.5 Les objets dans R

R est un langage orienté objet, donc il fonctionne avec des objets.
Les différents objets que l’on rencontre sous R sont :
— un nom : dans R, le nom doit commencer par une lettre et ne peut comporter que des
lettres, des chiffres, des espaces soulignés et des points.
En aucun cas, vous ne devez utiliser des espaces ou des caractères spéciaux comme
les ponctuations autres que le point. Ne pas utiliser des lettres à accent ou la cédille ;
— une classe : un vecteur, une matrice (tableau à deux dimensions), un array (tableau
à n dimensions), un dataframe, une liste, un facteur, une table ;
— un mode : numérique (nombre réel), caractère (chaîne de caractères à mettre entre
guillemets), logique (booléen), NULL (objet vide), liste (liste d’objets), fonction (une
fonction) ;
— une taille : la taille d’un objet est le nombre d’éléments qu’il contient.

9
2.5.1 Les commandes de base
objects() ou ls() Afficher la liste des objets en mémoire.
ls(pat="a") Afficher la liste des objets contenant le caractère
"a".
ls(pat=".a") Afficher la liste des objets commençant par "a".
ls.str() Afficher la liste des objets en mémoire avec des
details sur ces objets.
rm(x), rm(x,y) Effacer les objets x ou x et y de la mémoire.
rm(list=ls()), rm(list=ls(pat=".a")) Effacer tous les objets ou certains objets de la
mémoire.

Pour visualiser un objet x, il suffit de l’appeler à l’aide de x ou print(x).

2.5.2 Classes et attributs

R manipule plusieurs classes d’objets : les vecteurs, les facteurs, les arrays, les matrices,
les data frames, les ts, les listes. Pour connaître la classe d’un objet x, on utilise la com-
mande class(x). On peut savoir si un objet x est d’une certaine classe à l’aide des commandes
is.vector(x), is.factor(x), is.matrix(x), is.data.frame(x), is.ts(x)... (la réponse est TRUE ou
FALSE).
Chaque objet est caractérisé par son nom, son contenu, mais aussi par des attributs, dont
le mode (nul : NULL ; numérique : 1, 2.333, pi, Inf, -Inf, 2.1e23 ; caractère : "blabla" ; com-
plexe : 2+0i, 2i ; logique : TRUE, FALSE) et la longueur. Pour connaître ces deux attributs,
on utilise les commandes mode(x) et length(x).
Pour connaître les autres attributs attributes(x).

2.5.3 Les valeurs manquantes

Elles sont notées NA (not available) ou NaN (not a number). On peut savoir si un objet est
composé de valeurs manquantes à l’aide de is.na(x) ou is.nan(x). Ces commandes renvoient
un objet de mode logique de même longueur que x.
na.fail(x) retourne un message d’erreur si l’objet x contient au moins une valeur man-
quante.

2.6 Créer et manipuler des objets

Un objet peut être créé avec l’opérateur "assigner" qui s’écrit avec une flèche "<-" ou
"->", ou tout simplement avec un signe "=". Si l’objet existe déjà, sa valeur précédente est
effacée.
Attention, R distingue, pour les noms des objets, les minuscules des majuscules.

10
 R > x<-15
R > 15->x
R > x=15
R > x="blabla"

On peut convertir la classe des objets à l’aide de commandes comme as.matrix, as.data.frame,
as.ts..., leur mode à l’aide de as.numeric, as.logical, as.character, as.complex, leurs attri-
buts à l’aide de attr(x,"dim")<-.

2.6.1 Les structures de base

Il y a quatre structures qu’il est indispensable de connaître pour manipuler des données
statistiques :
— les vecteurs sont les objets de base qui permettent de stocker des valeurs d’un type
particulier. Tout échantillon ou toute séquence de valeurs est considéré comme un
vecteur. Ils sont la structure fondamentale de la statistique univariée et la syntaxe de
R est essentiellement orientée autour de cette notion ;
— les matrices - et de manière plus générale, les tableaux - sont une généralisation de
la notion de vecteur. Ce sont les objets appropriés pour les données multidimension-
nelles ;
— les listes sont des objets composites qui peuvent comporter des éléments de types dif-
férents. Ce sont des structures qui permettent de stocker des informations hétérogènes
et elles sont couramment utilisées pour rassembler les résultats d’une fonction qui a
effectué des opérations complexes telles qu’une régression linéaire ou une analyse de
données ;
— les tableau de données correspondent aux tableaux statistiques et stockent des ob-
servations de nature diverse concernant des individus statistiques. C’est la structure
de prédilection pour le stockage des jeux de données.

2.6.2 Les nombres et les vecteurs

Un nombre est considéré dans R comme un vecteur de taille 1 de mode numérique ou
complexe.

Créer des vecteurs

Un vecteur est une collection de longueur arbitraire constituée de valeurs d’un type déter-
miné. Toutes les valeurs contenues dans un vecteur doivent être du même type. Il existe ainsi
des vecteurs de nombres entiers, des vecteurs de nombres réels ou complexes, des vecteurs
de valeurs logiques, des vecteurs de chaînes de caractères.
Le type des composantes d’un vecteur s’appelle le mode du vecteur.
La longueur d’un vecteur est le nombre d’éléments qui le constituent.

11
 numeric(n) Créer un vecteur de taille n de mode numérique ne
contenant que des 0.
logical(n) Créer un vecteur de taille n de mode logique ne conte-
nant que des FALSE.
character(n) Créer un vecteur de taille n de mode caractère ne
contenant que des " ".
x <- c(1,2,3,4,5,6,7,8,9,10) Créer un vecteur contenant les valeurs
1,2,3,4,5,6,7,8,9,10.
x <- 1 :10 Créer un vecteur contenant une sequence régulère de
nombres entiers de 1 a 10.
x <- seq(1,5,by=0.5) Créer un vecteur contenant une séquence de nombres
réels dont le premier est 1, le dernier 5, l’incrément
utilise dans la progression de la sequence 0.5.
x <- seq(1,5,length=100) Créer un vecteur contenant une sequence régulière de
taille 100 de nombres reels dont le premier est 1, le
dernier 5.
x <- rep(1,100) Créer un vecteur contenant 100 fois le nombre 1.
x <- rep(1 :4,25) Créer un vecteur contenant 25 fois la suite 1,2,3,4.
x <- sequence(c(10,5)) Créer un vecteur contenant une suite de séquences
de nombres entiers qui chacune se termine par les
nombres 10 et 5.
x <- c("a","b","c") Créer un vecteur contenant les caractères a, b et c.
x <- rep("a",100) Créer un vecteur contenant 100 fois le caractère a.
noms <- paste("A",1 :5,sep=" ") Créer un vecteur contenant les caractères A1, A2, A3,
A4, A5.
cit <- "Elle dit : " blablabla"" Créer une chaîne de caractères des guillemets.
cat(cit) Afficher une chaîne de caractères contenant des guille-
mets.
x <- c(y,z) Créer un vecteur qui concatène les vecteurs y et z.

On peut générer des vecteurs contenant des données aléatoires à l’aide de la commande
rfun(n, p1 , p2 , . . .), ou fun indique la loi de probabilité, n le nombre de données générées,
p1 , p2 , . . . les paramètres de la loi de probabilité.
Exemples : rnorm(n,0,1), rexp(n,1), rpois(n,2), rchisq(n,100), rt(n,100), rf(n,100,50),
rbinom(n,100,0.5), runif(n,0,1)...

Remarque : On peut remplacer dans ces fonctions la lettre r par d, p ou q pour obtenir la
densité de probabilité, la fonction de répartition ou la valeur des quantiles.

Manipuler des vecteurs

• Les différents opérateurs
Les opérateurs arithmétiques classiques sont donnés par + (addition), - (soustrac-
tion), * (multiplication), / (division), ˆ (puissance), %% (congruence), %/% (divi-
sion entière).

12
 Les opérateurs de comparaison sont donnés par < (inférieur à), > (supérieur à),<=
(inférieur ou égal à), >= (supérieur ou égal à), == (égal à), ! = (différent de).
Ces opérateurs agissent sur les vecteurs élément par élément. Pour effectuer une com-
paraison globale de deux objets, on peut utiliser identical.
Les opérateurs logiques sont donnés par !x (non logique), x&y (et logique opérant
sur tous les éléments de x et y),
x&&y (et logique opérant sur le premier élément de x et y), x|y (ou logique opérant
sur tous les éléments de x et y), x||y (ou logique opérant sur le premier élément),
xor(x,y) (ou exclusif).
On code l’inégalité 0 < x < 1 par x > 0 & x < 1.
• Extraire une partie d’un vecteur
La śelection d’une partie d’un vecteur x s’opère à l’aide de la commande x[vecteur],
ou vecteur est soit un vecteur d’entiers positifs, soit un vecteur d’entiers négatifs, soit
un vecteur logique.

x[i], x[c(i,j)] Extraire la ième valeur ou la ième et la jème valeur du

vecteur x.
x[-i] Supprimer l’élément x[i] dans x.
x[-c(i,j)] Supprimer les éléments x[i] et x[j] dans x.
x[x>=1] Extraire les valeurs supérieures ou égales a 1 du vec-
teur x.
x[x%%2==0] Extraire les valeurs paires du vecteur x.
x[x>=1]<-1 Remplacer dans le vecteur x toutes les valeurs supé-
rieures ou égales a 1 par 1.
x[ !is.na(x)] Extraire les valeurs non manquantes de x. Idem a
na.omit(x).
x[is.na(x)]<-0 Remplacer les valeurs manquantes de x par 0.

• Les fonctions mat́hematiques

Les fonctions mathématiques de base sont toutes disponibles dans R (sqrt, abs, log,
exp, log10, sin, cos, tan, asin, ...).

13
 sum(x) Calculer la somme des éléments de x.
prod(x) Calculer le produit des éléments de x.
diff(x) Calculer la différence entre les éléments consécutifs
de x.
max(x) Donner le maximum des éléments de x.
min(x) Donner le minimum des éléments de x.
which.max(x) Donner l’indice du maximum des éléments de x.
which.min(x) Donner l’indice du minimum des éléments de x.
range(x) Donner le minimum et le maximum des éléments de
x.
length(x) Donner le nombre d’éléments dans x.
mean(x) Calculer la moyenne des éléments de x.
median(x) Calculer la médiane des éléments de x.
var(x), cov(x) Calculer la variance empirique des éléments de x.
var(x,y), cov(x,y) Calculer la covariance entre x et y.
corr(x,y) Calculer la corrélation linéaire entre x et y.
sd(x) Calculer l’écart type empirique de x.
quantile(x) Calculer le quantile empirique de x.
round(x,n) Arrondir les éléments de x a n chiffres après la virgule.
rev(x) Inverser l’ordre des éléments de x.
sort(x) Ordonner les éléments de x.
rev(sort(x)) Ordonner les éléments de x dans l’ordre descendant.
rank(x) Donner les rangs des éléments de x.
order(x) Donner les coordonnées du plus petit élément de x, du
deuxième plus petit élément de x, etc.
pmin(x,y), pmax(x,y) Donner un vecteur dont le ième élément est le mini-
mum ou le maximum entre x[i] et y[i].
cumsum(x), cumprod(x) Donner un vecteur dont le ième élément est la somme
ou le produit des éléments x[1] à x[i].
cummin(x), cummax(x) Donner un vecteur dont le ième élément est le mini-
mum ou le maximum des éléments x[1] à x[i].
match(x,y) Donner un vecteur de même longueur que x contenant
les éléments de x qui sont dans y (NA sinon).
which(x==2) Donner les indices des éléments de x égaux a 2.
choose(n,k) Calculer les combinaisons de paramètres n et k.
unique(x) Supprimer les éléments dupliqués de x.
table(x) Créer un tableau des effectifs des différentes valeurs
de x.
sample(x,k) Re-échantillonner aléatoirement et sans remise k élé-
ments dans x.
sample(x,k,REPLACE=TRUE) Re-échantillonner aléatoirement et avec remise k élé-
ments dans x.
• Manipuler des vecteurs logiques
all(x) Tester si tous les éléments de x sont TRUE.
any(x) Tester si au moins un des éléments de x est TRUE.

14
 On peut utiliser les opérateurs arithmétiques, les FALSE étant transformés en 0, les
TRUE en 1.

2.6.3 Les listes

Après les vecteurs, les listes sont les structures les plus utilisées pour stocker des données.
Alors que les vecteurs sont homogènes, c’est-à-dire ne peuvent contenir que des données qui
sont toutes du même type, les listes au contraire sont hétérogènes : ce sont des collections
séquentielles d’objets quelconques.
Les éléments (ou composantes) d’une liste peuvent être tous de types différents. Il peut
s’agir de valeurs simples (valeurs numériques, valeurs logiques, chaînes de caractères) ou
d’objets plus complexes tels que des vecteurs, des matrices, des tables ou même d’autres
listes. Les listes sont donc des objets récursifs.
La structure de liste est très fréquemment utilisée justement pour définir des objets nou-
veaux et stocker leurs composantes. Elle est aussi utilisée dans les fonctions qui renvoient
des résultats multiples.
Chaque composante d’une liste est caractérisée par son indice dans la liste et peut être
nommée, exactement comme les vecteurs.

Construction de listes
Les listes sont créées au moyen de la fonction list. Les arguments de cette fonction sont
les objets ou valeurs qui constituent les éléments de la liste. Ces éléments peuvent être nom-
més en utilisant une syntaxe de la forme nom=valeur pour les arguments. Si aucun nom
n’est spécifié, les éléments seront simplement identifiés par leur indice. Le premier élément
correspond à l’indice 1, comme pour les vecteurs.
Dans l’exemple qui suit, on crée une liste comportant une valeur numérique entière, une
valeur logique et un vecteur :

> L1 <- list(12345, TRUE, c(12, 13, 11, 10.5, 9))

> L2 <- list(ID=12345, traitement=TRUE, taux=c(12, 13, 11, 10.5, 9))

> scan(what=list(a=0, b="", c=TRUE))

1: 1 abc FALSE
2: -1 def TRUE
3:
Read 2 records
$a
[1] 1 -1

$b
[1] "abc" "def"

$c
[1] FALSE TRUE

15
> L1
[[1]]
[1] 12345

[[2]]
[1] TRUE

[[3]]
[1] 12.0 13.0 11.0 10.5 9.0

> L2
$ID
[1] 12345

$traitement
[1] TRUE

$taux
[1] 12.0 13.0 11.0 10.5 9.0

> names(L2)
[1] "ID" "traitement" "taux"

Indexation

> L1[3]

[[1]]
[1] 12.0 13.0 11.0 10.5 9.0

> L1[[3]]

[1] 12.0 13.0 11.0 10.5 9.0

2.6.4 Les facteurs

Un facteur est constitué des valeurs de la variable catégorique (ou qualitative) corres-
pondante et des différents niveaux possibles de cette variable (même ceux qui ne sont pas
représentés dans les données).

Créer des facteurs

De manière générale, on crée un facteur au moyen de la fonction factor. Cette fonction
prend en argument un vecteur correspondant à une variable qualitative. Par exemple, voici
un vecteur arbitraire constitué des valeurs "A", "B" et "C" :

16
> y <- c("B","C","B","C","B","B","A","A","B","A","A","C")
> y
[1] "B" "C" "B" "C" "B" "B" "A" "A" "B" "A" "A" "C"

On le transforme en un facteur avec la fonction factor comme ceci :

> F <- factor(y)

> F
[1] B C B C B B A A B A A C
Levels: A B C

Dans l’exemple précédent, les seuls niveaux présents sont A, B et C mais on peut ima-
giner que les valeurs possibles sont toutes les lettres de A à E et que simplement, dans le
vecteur y, les lettres D et E n’étaient pas représentées.
Dans ce cas, le facteur serait construit de la manière suivante :
> F <- factor(y,levels=LETTERS[1:5])
> F
[1] B C B C B B A A B A A C
Levels: A B C D E
Dans l’exemple suivant, on renomme automatiquement les niveaux avec une lettre N qui
est suffixé par un entier entre 1 et 5 :
> factor(y,levels=LETTERS[1:5],labels="N")

[1] N2 N3 N2 N3 N2 N2 N1 N1 N2 N1 N1 N3
Levels: N1 N2 N3 N4 N5
Les niveaux N1, N2, etc. correspondent aux lettres A, B, etc. de l’exemple précédent.
Il existe deux fonctions utiles concernant les niveaux d’un facteur :
— la fonction levels renvoie un vecteur contenant les niveaux du facteur ;
— la fonction nlevels renvoie le nombre de niveaux déclarés dans le facteur.
Par exemple :

> levels(F)
[1] "A" "B" "C" "D" "E"
> nlevels(F)
[1] 5

Facteurs ordonnés On utilise fréquemment en statistique, la notion de variable ordinale :

c’est une variable qualitative pour laquelle on peut définir une notion d’ordre.
Voici un exemple à partir d’un vecteur arbitraire comportant 10 mentions :
> mentions <- c("AB","TB","AB","B","P","P","TB","B","AB","TB")
> factor(mentions,ordered=TRUE, levels=c("P","AB","B","TB"))
[1] AB TB AB B P P TB B AB TB
Levels: P < AB < B < TB

17
 factor(c(1,2,3)), factor(1 :3)
factor(1 :3,levels=1 :5)
factor(1 :3,labels=c("A","B","C")), Créer un facteur de valeurs A,B,C, et de ni-
factor(c("A","B","C"))
factor(1 :4,exclude=3)
gl(2,3)
gl(2,3,length=30)
gl(2,3, label=c("A","B"))
Créer un facteur de valeurs 1,2,3 et de ni-
veaux 1,2,3.
Créer un facteur de valeurs 1,2,3 et de ni-
veaux 1,2,3,4,5.
veaux A,B,C.
Créer un facteur de valeurs 1,2,NA,4 et de
niveaux 1,2,4.
Créer un facteur de valeurs 1,1,1,2,2,2 et de
niveaux 1,2.
Créer un facteur de valeurs 1,1,1,2,2,2, répé-
tées 5 fois (longueur totale=30) de niveaux
1,2.
Créer un facteur de valeurs A,A,A,B,B,B de
niveaux A,B.

Manipuler des facteurs

ordered(x) Transformer x en facteur ordonné.
level(x) Extraire les niveaux du facteur x.

Utiliser des facteurs

Supposons que l’on dispose pour une population donnée contenant des hommes et des
femmes (le sexe est donné par un facteur sexe contenant les valeurs M,F de niveaux M,F) de
la taille de chaque individu (la taille est donnée par un vecteur numérique taille correspondant
au facteur défini précédemment). On peut appliquer une fonction, par exemple la moyenne ou
une fonction mafonction programmée, aux éléments de taille en fonction du sexe des indi-
vidus à l’aide de la commande tapply(taille,sexe,mean) ou tapply(taille,sexe,mafonction).
Si l’on dispose d’un second facteur, par exemple âge, on peut utiliser
taggregate(taille,list(sexe,age),mafonction)
qui appliquera mafonction aux éléments de taille en fonction des niveaux de sexe et de
âge.

2.6.5 Matrices et tableaux

Les matrices et les tableaux (en anglais arrays) sont les équivalents multidimensionnels
des vecteurs. Un tableau peut avoir plusieurs dimensions et les matrices correspondent aux
tableaux à deux dimensions.
En interne, les tableaux sont stockés comme les vecteurs auxquels on a attaché un attribut
appelé dim qui contient les dimensions du tableau et un attribut optionnel appelé dimnames
qui contient les noms de ces dimensions.
Une matrice correspond a un vecteur auquel on ajoute un argument dim définissant le
nombre de lignes et de colonnes. Ses colonnes sont donc de même classe.
Si x est une matrice, dim(x) retourne la dimension de la matrice x, nrow(x) le nombre
de lignes, ncol(x) le nombre de colonnes. Si x est un vecteur, dim(x) retourne NULL.

18
 L’attribut dimnames est stocké comme une liste comportant une composante pour chaque
dimension. Par exemple, pour une matrice de taille 3 × 4, l’attribut dimnames est une liste
à deux éléments : premier élément est un vecteur contenant les noms des 3 lignes, le second
est un vecteur contenant les noms des 4 colonnes.

Création de matrices
On fabrique une matrice au moyen de la fonction matrix.

> m<-matrix(1:12,nrow=3,ncol=4)
> m
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
matrix(1,nr=2,nc=2) Créer une matrice 2 × 2 ne contenant que des 1.
matrix(1 :6,2,3) Créer une matrice 2 × 3 remplie colonne par colonne
par les valeurs du vecteur 1 :6.
matrix (1 :6,2,3,byrow=TRUE) Créer une matrice 2 × 3 remplie ligne par ligne par les
valeurs du vecteur 1 :6.
x=1 :6 ;dim(x)=c(2,3) Idem a matrix(1 :6,2,3).
diag(3) Créer la matrice identité 3 × 3. La
diag(c(1,2,3)) Créer une matrice diagonale d’éléments diagonaux
1,2,3.
diag(c(1,2,3),nr=3,nc=5) Créer une matrice 3 × 5 dont la première sous-matrice
3 × 3 est diag(c(1,2,3)).
rbind(x,y), cbind(x,y) Juxtaposer les matrices x et y (cote à cote ou l’une au
dessous de l’autre).
fonction matrix possède aussi un argument optionnel dimnames pour déclarer des noms de
lignes et des noms de colonnes. En voici un exemple :

> n<-matrix(1:12,nr=3,dimnames=list(c("U","V","W"),c("A","B","C","D")))
> n
A B C D
U 1 4 7 10
V 2 5 8 11
W 3 6 9 12

On peut aussi créer un tableau à partir d’un vecteur simplement en lui attachant un attribut
dim. Les deux instructions suivantes commencent par créer un vecteur de longueur 12 puis
modifient sa dimension pour en faire une matrice de taille 3 × 4.

> v<-1:12
> dim(v)<-c(3,4)
> v
[,1] [,2] [,3] [,4]

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

Il est aussi une fonction dimnames qui permet de nommer les lignes et les colonnes
d’une matrice déjà existante. Par exemple :

> dimnames(n)<-list(c("X","Y","Z"),c("P","Q","R","S"))
> n
P Q R S
X 1 4 7 10
Y 2 5 8 11
Z 3 6 9 12

Alternativement, on peut utiliser les fonctions rownames et colnames pour déclarer séparé-
ment des noms de lignes ou des noms de colonnes.
La fonction scan permet aussi de saisir les éléments d’une matrice de manière interactive.
En voici un exemple où on construit une matrice à 2 lignes et 3 colonnes :

> matrix(scan(),nrow=2)
1: 1 2
3: -1 1
5: 0 3
7:
Read 6 items
[,1] [,2] [,3]
[1,] 1 -1 0
[2,] 2 1 3

> matrix(scan(),nrow=2,byrow=TRUE)
1: 1 2 3
4: 0 -1 -2
7:
Read 6 items
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 0 -1 -2

Manipuler des matrices

• Extraire une partie d’une matrice
x[i,j] Extraire la valeur de la ième ligne et jème colonne de
x.
x[,j] Extraire la colonne j de x.
x[i,] Extraire la ligne i de x.
x[-c(1,5),] Supprimer les lignes 1 et 5 de x.

20
> m[2:3,3:4]
[,1] [,2]
[1,] 8 11
[2,] 9 12

> m[,4]
[1] 10 11 12
> m[,4,drop=FALSE]
[,1]
[1,] 10
[2,] 11
[3,] 12

On peut, comme pour les vecteurs, extraire des éléments d’une matrice x à l’aide de
vecteurs logiques.
• Les opérateurs et fonctions mathématiques
Les opérateurs disponibles pour les vecteurs sont également utilisables pour des matrices
de même dimension, tout comme la plupart des fonctions mathématiques. Ils agissent élé-
ment par élément.
On peut appliquer ces opérateurs ou fonctions mathématiques à certains éléments d’une
matrice seulement à l’aide de la commande apply() :

apply(x,1,mean) Calculer la moyenne des éléments de x ligne par ligne.

apply(x,2,mafonction) Appliquer mafonction aux éléments de x colonne par
colonne.
apply(x,c(1,2),mafonction) Appliquer mafonction aux éléments de x ligne par
ligne et colonne par colonne.
Pour les matrices numériques, on dispose en plus des opérateurs de calcul matriciel clas-
siques et de fonctions propres au calcul matriciel.
x%*%y Calculer le produit matriciel de x par y.
t(x) Donner la transposee d’une matrice x.
diag(x) Extraire la diagonale de la matrice x.
diag(x)<-0 Remplacer les éléments de la diagonale de x par 0.
solve(x) Calculer l’inverse de la matrice x.
solve(A,b) Résoudre l’équation Ax=b.
e<-eigen(x) Calculer les valeurs et vecteurs propres d’une matrice
symétrique x.
e$val Retourner les valeurs propres de x.
e$vec Retourner les vecteurs propres de x.
svd(x) Donner la décomposition en valeurs singulières de x.
prod(svd(x)$d) Calculer la valeur absolue du determinant d’une ma-
trice carrée x.

21
2.6.6 Les arrays
Les arrays sont des tableaux à k dimensions, généralisant les matrices qui sont en fait des
arrays avec k = 2.

> A<-array(1:24,dim=c(3,4,2))
> A
, , 1

[,1] [,2] [,3] [,4]

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

, , 2

[,1] [,2] [,3] [,4]

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

Beaucoup des commandes disponibles pour les matrices se généralisent naturellement aux
arrays.

2.6.7 Tables de données

Les tableaux statistiques (tableaux de données) représentent des observations de variables
ou des caractères concernant des individus ou des unités statistiques. Il s’agit de tables à
deux entrées : usuellement, les individus sont représentés par les lignes et les variables sont
représentés par les colonnes. Sur chaque ligne, on lit donc les valeurs observées des variables
pour un individu donné. En colonnes, on lit les valeurs d’une certaine variable pour chaque
individu.

Notion de tableau de données

Un data.frame est un tableau de données composé de un ou plusieurs objets de même
longueur mais pouvant être de modes (ou types) différents. On peut voir un tableau de
données comme une liste de colonnes : chaque colonne est un vecteur d’un type donné (un
vecteur numérique ou un vecteur logique ou un vecteur de chaînes de caractères )
Un tableau de données possède, comme les matrices, un attribut dim.

Création d’un tableau de données

Voici, par exemple, un tableau de données comportant 5 individus et 3 variables, c-à-d 5
lignes et 3 colonnes :

22
> df<-data.frame(poids=c(53,82,75,56,95),
fumeur=c(TRUE,FALSE,TRUE,FALSE,FALSE),
sexe=c("F","H","H","F","H"),
row.names=c("Alice","Albert","Achille","Anne","Aristide"))
> df
poids fumeur sexe
Alice 53 TRUE F
Albert 82 FALSE H
Achille 75 TRUE H
Anne 56 FALSE F
Aristide 95 FALSE H

On peut aussi nommer les lignes d’un tableau de données déjà existant au moyen de la
fonction rownames comme ceci :

> rownames(df)<-c("Alice","Albert","Achille","Anne","Aristide")

Avec cette syntaxe, on peut même renommer isolément un individu particulier :

> rownames(df)[5]<-"Aristode"

L’indexation des tableaux de données se fait exactement comme celle des matrices. La valeur
de la 2e variable pour le 4e individu du tableau est :

> df[4,2]
[1] FALSE

De même, toute la première colonne du tableau de données peut être désignée comme df [, 1]
ou, en utilisant le nom de la colonne plutôt que l’indice, comme df [, "poids"] :

> df[,"poids"]
[1] 53 82 75 56 95

2.6.8 Tables statistiques

Les tables statistiques ne sont pas la même chose que les tableaux de données vus à la
section précédente. Les tables décrivent des données regroupées et contiennent les effectifs
d’individus pour lesquels une variable prend une valeur particulière.
En général, on dit que les tableaux statistiques sont des tableaux de données élémentaires
tandis que les tables sont des tableaux de données regroupées ou des tableaux d’effectifs.
Dans R, il existe un objet de type table. Cette structure est analogue aux objets de type
array. Une table peut avoir plusieurs dimensions et les valeurs qu’elle contient sont des
nombres entiers. A deux dimensions ou plus, on parle de table de contingence.
La fonction table permet de créer une table à partir d’un vecteur. Dans l’exemple suivant,
on part d’un vecteur V de 20 données arbitraires qui sont des valeurs entières entre -2 et 2 :

23
> V <- c(-2,1,0,2,2,0,-1,1,-1,1,0,-2,2,2,2,2,-2,-2,1,-2)
> table(V)
V
-2 -1 0 1 2
5 2 3 4 6

La première ligne affichée est l’ensemble des valeurs présentes dans le vecteur et le deuxième
indique le nombre de fois que chaque valeur est rencontrée.
De manière générale, la fonction table s’applique aux colonnes d’un tableau de données.
Pour obtenir une table de contingence de dimension 2, il faut disposer de deux variables dans
un tableau de données.
A titre d’exemple, on va se donner un deuxième vecteur arbitraire W de 20 éléments
prenant les valeurs 1 et 2 :

> W <- c(2,1,1,2,1,2,1,1,2,2,1,1,2,2,2,1,1,1,1,1)

On regroupe maintenant V et W dans un tableau de données et on applique la fonction table

comme ceci :

> dfvw <- data.frame(V,W)

> table(dfvw)
W
V 1 2
-2 4 1
-1 1 1
0 2 1
1 3 1
2 2 4

La valeur 4 en haut à gauche de cette table de contingence signifie qu’il y a 4 observations

dans le tableau de données représenté par la variable dfvw pour lesquelles on a à la fois
V = −2 et W = 1.
On verra plus loin que la lecture de données dans un fichier à l’aide de la commande
read.table() crée automatiquement un data.frame.
La commande data.frame(x,y,...) permet de créer un tableau de données contenant les
objets x,y... Les objets entrant dans la commande doivent être de même longueur, ou si un de
ces objets est plus court, il est alors recycle un nombre entier de fois suffisant.
On peut concaténer deux tableaux de données à l’aide de c(table1,table2).

Manipuler des tableaux de données

x=factor(c("M","F","F","M","F","F"))
y=c(1.75,1.68,1.72,1.67,1.59,1.65)

24
 données=data.frame(y,x) Créer un tableau de données contenant le vecteur y et
le facteur correspondant x.
summary(données) Afficher un résumé de données.
données=data.frame(taille=y,sexe=x) Changer les noms de x et y.
names(données) Afficher les noms des objets contenus dans données.
données=data.frame(taille=y,sexe=x, Donner des noms aux colonnes et aux lignes.
row.names=paste("Individu",1 :6,sep=""))
données$taille, données[["taille"]] Extraire l’objet taille du data.frame données.
données[[1]] Extraire le premier objet contenu dans données.
attach(données) Rajouter données dans la liste des répertoires de travail
en position 2. Enregistrer dans ce répertoire les objets
taille et sexe du data.frame données.
search() Vérifier la position de données.
taille Retourner les valeurs de données$taille.
find(taille) Trouver le répertoire dans lequel se trouve l’objet
taille.
ls(pos=2) Afficher la liste des objets du deuxième répertoire, ici
données.
taille[sexe=="M"] Extraire les éléments de taille correspondant aux indi-
vidus de sexe masculin.
mafonction(taille[sexe=="M"]) Appliquer mafonction aux éléments de taille corres-
pondant aux individus de sexe masculin.
detach(données) Détacher le répertoire données.

lapply(données,mafonction) Appliquer mafonction à chacun des objets contenus

dans données.
apply(données,1,mafonction) Appliquer mafonction aux différentes lignes de don-
nées.
Pour concaténer des objets de R, on utilise la fonction paste :

> paste("X",1:5,sep="-")
[1] "X-1" "X-2" "X-3" "X-4" "X-5"
> paste(c("X","Y"),1:5,"txt",sep=".")
[1] "X.1.txt" "Y.2.txt" "X.3.txt" "Y.4.txt" "X.5.txt"
> paste(c("X","Y"),1:5,sep=".",collapse="+")
[1] "X.1+Y.2+X.3+Y.4+X.5"

L’argument collapse rassemble tous les éléments dans un vecteur de longueur 1. Pour
l’extraction on utilise la fonction substr :

> substr("freerider",5,9)
[1] "rider"

25
2.6.9 Les ts
On ne détaillera pas ici les commandes propres aux séries temporelles. On précisera juste
la commande permettant de créer de telles séries temporelles :
ts(data,start=,end=,frequency=,deltat=,ts.eps=,class,names).

2.6.10 Notion d’objet

Les sections qui précédent ont introduit les structures essentielles utilisées avec R : vec-
teurs, listes, matrices, tableaux multidimensionnels, tableaux de données, tables. On désigne
ces structures sous le nom d’objets. Cette notion d’objet est fondamentale pour ce logiciel
car tous les éléments manipulés sont considérés comme des objets. Un objet est une abstrac-
tion permettant d’encapsuler des propriétés particulières. Un objet de classe matrice n’a pas
les mêmes propriétés ou caractéristiques qu’un objet de classe liste.
Voici quelques exemples :

> m <- matrix(nrow=2,ncol=3)

> class(m)
[1] "matrix"

> L <- list(x=1:5,y="abcde")

> class(L)
[1] "list"

> F <- factor(c(1,2,1,2,1,1,1,1,2,1,2,2))

> class(F)
[1] "factor"

> T <-table(F)
> class(T)
[1] "table"

le mot vecteur est ici sous-entendu : il faut comprendre respectivement vecteur numérique,
vecteur entier, vecteur de chaînes de caractères.

> X <- c(3.14,2.78)

>
> class(X)
[1] "numeric"
> Y <- 1:10
> class(Y)
[1] "integer"
> V <- LETTERS[1:10]
> class(V)
[1] "character"

26
Attributs et composantes d’un objet
Les objets, au sens qui a été expliqué dans la section précédente, possèdent des attributs
et parfois des composantes.
La fonction attributes permet de connaître les attributs attachés à un objet. En voici un
exemple dans le cas d’une matrice :

> M <- matrix(1:4, nrow=2, dimnames=list(c("X","Y"),c("A","B")))

> M
A B
X 1 3
Y 2 4
> attributes(M)
$dim
[1] 2 2

$dimnames
$dimnames[[1]]
[1] "X" "Y"

$dimnames[[2]]
[1] "A" "B"

La fonction attributes renvoie une liste de tous les attributs avec leur valeur. Pour connaître
seulement les noms des attributs, on peut appliquer la fonction names à la liste renvoyée,
comme ceci :

> names(attributes(M))
[1] "dim" "dimnames"

Il existe aussi une fonction attr pour obtenir la valeur d’un attribut particulier. Par exemple :

> attr(M,"dim")
[1] 2 2

On peut modifier un attribut en utilisant cette fonction comme valeur à gauche :

> attr(M,"dimnames") <- list(c("L1","L2"),c("V1","V2"))

> M
V1 V2
L1 1 3
L2 2 4

Dans le cas d’une liste, il ne faut pas confondre les attributs avec les composantes. Les
attributs sont obtenus au moyen de la fonction attributes tandis que les composantes sont
obtenues au moyen de la fonction names. Voici un exemple simple pour faire la distinction :

27
> L <- list(x=1:5,y="abcde")
> names(L)
[1] "x" "y"
> attributes(L)
$names
[1] "x" "y"

Il y a ici deux composantes (x et y) et un seul attribut (names).

2.7 Lire et enregistrer des données dans un fichier

2.7.1 Lire des données
R peut lire des données stockées dans des fichiers de différents formats à l’aide des
fonctions read.table, scan, read.fwf.
Si l’on dispose par exemple d’un fichier nomme données.dat en format ASCII dans un
répertoire /home/etudiant/R,
la commande données=read.table("/home/etudiant/R/données.dat") crée un data.frame
nommé données. Les objets contenus dans données sont nommes par defaut V1,V2, etc. Plu-
sieurs options peuvent être utilisées dont voici les valeurs par défaut :

read.table(file,header=F
ALSE,sep="",quote="\"f",dec=".",
row.names,col.names,
as.is=FALSE,
na.strings="NA",colClasses=NA,nrows=-1,skip=0,check.names=TRUE,
fill= !blank.lines.skip,
strip.white=FALSE,blank.lines.skip=TRUE,comment.char="\sharp").

La fonction scan est plus flexible que read.table dans le sens ou elle permet de spécifier
le mode des variables.
La fonction read.fwf sert a lire des fichiers ou les données sont dans un format de largeur
fixée. Les options sont les mêmes que pour read.table sauf widths qui spécifie la largeur des
champs.

2.7.2 Le package data.table

Pour plus de d’etails sur la fonction data.table se référer par exemple à la page http://
larmarange.github.io/analyse-R/manipulations-avancees-avec-data-table.
html.
Le package data.table permet de traiter de manière efficace, tant du point de vue du
temps d’exécution que de l’empreinte mémoire utilisée, des tableaux de données volumi-
neux, voire très volumineux.

28
Importation avec fread
fread permet la lecture de fichiers “plats” et permet aussi l’importation de données volu-
mineuses.
Prenons l’exemple du fichier listings.csv
#Importation avec fread
library(data.table)
system.time(read.table(file.choose(),header = TRUE,sep=";"))
cat("Taille en (MB):", round(file.info(file.choose())$size/1024^2),"\n")
system.time(fread(file =file.choose()))

2.7.3 Enregistrer des données

La fonction write.table écrit dans un fichier un objet, typiquement un data.frame. Les
options par défaut sont les suivantes :
write.table(x,file,append=FALSE,quote=TRUE,sep=" ", eol="\n",na="NA",dec=".",
row.names=TRUE, col.names=TRUE,qmethod=c("escape","double")).
Pour enregistrer des objets de n’importe quel type dans un fichier, on utilise la commande
save, par exemple
save(x,y,z,file="messorties.dat") sauvegarde les objets x, y et z dans le fichier messor-
ties.dat. On pourra les charger en mémoire ultérieurement avec load("messorties.dat").

2.7.4 Exercice
On cherche à étudier les données de Hoesmer et Lemeshow (1989) stockées dans la
library MASS de R sous le nom de birthwt. Le but de cet exercice n’est pas de mener cette
étude, mais d’apprendre à manipuler les données fournies. On verra l’étude complète dans
un TP ultérieur.
1. Importer les données. De quelle classe sont-elles ? Quelles sont les classes des objets
contenus dans birthwt ?
2. Transformer low, race, smoke en facteurs dans les données d’origine birthwt.
3. Transformer ptl en un facteur prenant la valeur 0 si ptl=0, 1 sinon. Faire la même
chose pour ht et ui.
Transformer ftv en un facteur dé niveaux "0", "1" et "2+".
4. Eliminer toutes les données correspondant aux mères âgées de moins de 20 ans et de
plus de 41 ans (compris).
5. Calculer la moyenne des poids de naissance pour chacun des différents facteurs (sauf
low).
6. Calculer la moyenne des poids de naissance pour les classes de femmes agées de 21
à 25 ans, de 26 à 30 ans, de 31 à 35 ans, de 36 à 40 ans.
7. Calculer la moyenne des poids de naissance pour 4 classes de femmes de même
cardinal (à un près), rangées par âge croissant.
8. Retransformer le facteur smoke en entier. Que remarque-t-on ?

29
2.7.5 Solution de l’exercice
Facteurs de risque associés aux nourrissons de faible poids
Nous commençons ainsi. Vous ne devez pas exécuter la bibliothèque commande ("MASS")
si vous utilisez toujours la même session de R. Essayez de taper search(), et si vous voyez
"package : MASS" parmi les paquets listés, il est déjà chargé.

2.8 Statistique descriptive

La statistique descriptive (qui s’oppose habituellement à la statistique inférentielle et
théorique) est la branche des statistiques qui a pour objectif principal de dégager les carac-
téristiques des données recueillies ou observées. Les méthodes qu’elle utilise sont de deux
types : les méthodes graphiques permettent de visualiser les données alors que les méthodes
numériques ont pour objectif de définir des indicateurs caractéristiques de la répartition des
données. Dans les deux cas, R fournit des outils performants pour atteindre ces objectifs.

2.8.1 Indicateurs statistiques

Certaines fonctions renvoient une valeur numérique : c’est le cas des indicateurs de ten-
dance centrale comme la moyenne ou la médiane, ou des indicateurs de dispersion comme
la variance ou l’écart-type.
Voici quelques exemples d’utilisation :

> v <- seq(0,20,0.6)

> sum(v)
[1] 336.6
> prod(v)
[1] 0
> mean(v)
[1] 9.9
> median(v)
[1] 9.9
> sd(v)
[1] 5.974948
> var(v)
[1] 35.7

La fonction IQR est l’abbréviation de inter-quartile range et renvoie l’étendue inter-quartile,

c’est-à-dire la différence entre le troisième et le premier quartile (voir à la section 2.8.2). La
fonction mad est l’abréviation de median absolute deviation : elle calcule la médiane des
valeurs absolues des écarts par rapport à la médiane de l’échantillon.

> IQR(v)
[1] 9.9
> mad(v)
[1] 7.56126

30
 D’autres fonctions renvoient un vecteur : c’est le des quantités cumulées (somme, pro-
duit, minimum, maximum). En voici quelques exemples :
> cumsum(v)
[1] 0.0 0.6 1.8 3.6 6.0 9.0 12.6 16.8 21.6 27.0
33.0 39.6
[13] 46.8 54.6 63.0 72.0 81.6 91.8 102.6 114.0 126.0 138.6
151.8 165.6
[25] 180.0 195.0 210.6 226.8 243.6 261.0 279.0 297.6 316.8 336.6
> cummax(v)
[1] 0.0 0.6 1.2 1.8 2.4 3.0 3.6 4.2 4.8 5.4 6.0 6.6
7.2 7.8 8.4
[16] 9.0 9.6 10.2 10.8 11.4 12.0 12.6 13.2 13.8 14.4 15.0 15.6
16.2 16.8 17.4
[31] 18.0 18.6 19.2 19.8
On a vu précédemment que les valeurs manquantes sont désignées par le symbole spécial
NA. Dans le calcul des indicateurs statistiques, la présence de ces valeurs est en général un
problème : on ne peut pas calculer, par exemple, la moyenne de valeurs qui n’existent pas.
On peut cependant décider de les ignorer en utilisant un argument appelé na.rm (rm est
l’abréviation de remove).
A titre d’exemple, on va augmenter la taille du vecteur v de 5 unités mais sans donner de
valeur aux nouveaux éléments. Ils recevront alors la valeur NA.
> length(v)<-length(v)+5
> mean(v)
[1] NA
> mean(v,na.rm=TRUE)
[1] 9.9
> sd(v)
[1] NA
> sd(v,na.rm=TRUE)
[1] 5.974948
La fonction cor calcule le cœfficient de corrélation linéaire entre deux vecteurs numé-
riques de même longueur. Elle prend en argument les deux vecteurs. Par exemple :
> w=v^2
> cor(v,w)
[1] 0.9665001
Les fonctions pmin et pmax calculent respectivement les minima et les maxima paral-
lèles entre plusieurs vecteurs.
> pmin(1:10,10:1)
[1] 1 2 3 4 5 5 4 3 2 1
> pmax(1:10,10:1)
[1] 10 9 8 7 6 6 7 8 9 10

31
La fonction weighted.mean calcule des moyennes pondérées. Elle prend en argument un
vecteur numérique et un vecteur de poids de même longueur. La somme des poids n’a pas né-
cessairement à être égale à 1 : la fonction se charge de normaliser le résultat. Dans l’exemple
suivant, on prend un vecteur de trois notes obtenues dans des matières ayant pour cœfficient
3, 1 et 1 respectivement et on calcule la moyenne pondérée :

> weighted.mean(c(8,12,13),c(3,1,1))
[1] 9.8

Il faut noter que les fonctions var et sd renvoient respectivement la variance et l’écart-type
non-biaisés de l’échantillon. Si on note N la taille de l’échantillon x, il s’agit pour la variance
de la quantité :
1 X
V ar(x) = N (xi − x̄)2 .
N − 1 i=1
Autrement dit, c’est la somme des carrés des écarts à la moyenne, divisée par N − 1 et non
pas par N . L’écart-type renvoyé par la fonction sd est la racine carrée de cette variance.
Il n’y a pas de fonction pour calculer directement la variance théorique mais on peut la
calculer directement comme ceci :

> Var <- sum( (v-mean(v))^2)/length(v)

[1] 34.65

2.8.2 Quantiles
Les quantiles (ou fractiles) sont les quantités qui permettent de découper un échantillon
en intervalles contenant une certaine proportion de la taille totale. Les quantiles les plus
utilisés sont les trois quartiles qui découpent l’échantillon en quatre intervalles contenant
chacun 25 % de l’effectif total. Les déciles sont ceux qui définissent des intervalles contenant
chacun 10 % de l’effectif total.
La fonction quantile prend en premier argument le vecteur numérique présentant l’échan-
tillon et admet aussi un argument optionnel probs qui est un vecteur de probabilités indiquant
la proportion de l’effectif total que doit contenir approximativement chaque intervalle. par
défaut, si l’argument probs n’est pas spécifié, la fonction calcule les quartiles. Par exemple,
en reprenant le vecteur v de la section précédente :

> quantile(v)
0% 25% 50% 75% 100%
0.00 4.95 9.90 14.85 19.80

Pour calculer les déciles, on spécifie un vecteur de probabilités dont toutes les valeurs sont
égales à 0,1, c’est-à-dire 1/10. Par exemple :

> quantile(v,probs=0:10/10)
0% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100%
0.00 1.98 3.96 5.94 7.92 9.90 11.88 13.86 15.84 17.82 19.80

32
La fonction quantile supporte l’argument na.rm pour ignorer les valeurs manquantes et pos-
sède aussi un argument logique names pour indiquer si les valeurs renvoyées doivent être un
vecteur nommé. C’est le cas par défaut. Si on souhaite obtenir uniquement les valeurs, on
supprimera les noms comme ceci :

> quantile(v,probs=0:10/10,names=FALSE)
[1] 0.00 1.98 3.96 5.94 7.92 9.90 11.88 13.86 15.84 17.82 19.80

2.8.3 Résumés
Quelques fonctions permettent d’obtenir une vue résumée du contenu d’un objet.
La plus utilisée est la fonction summary. C’est une fonction générique qui calcule les
principales valeurs permettant de résumer les données contenues dans un objet.
Avec d’autres types d’objets, comme par exemple des séries temporelles ou des modèles
linéaires, la fonction summary fournit d’autres renseignements.

> summary(v)
Min. 1st Qu. Median Mean 3rd Qu. Max.
0.00 4.95 9.90 9.90 14.85 19.80

2.8.4 Statistiques bidimensionnelles

En statistique multivariée, on rencontre fréquemment des tableaux numériques à deux
dimensions (matrices, dataframes, tables de contingence). Il existe quelques fonctions utiles
pour calculer des indicateurs statistiques sur chaque ligne ou chaque colonne d’un tel ta-
bleau :
— les fonctions rowSums et colSums calculent respectivement les sommes de chaque
ligne ou chaque colonne d’une matrice numérique ;
— les fonctions rowMeans et colMeans calculent respectivement les moyennes de chaque
ligne ou chaque colonne d’un tableau bidimensionnel.
Ces fonctions sont à utiliser chaque fois que cela est possible car ce sont des primitives
définies dans le noyau de R qui sont optimisés pour tirer le meilleur parti de la vectorisation.
Exemples :

> t <- matrix(1:12,nrow=3,ncol=4)

> t
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> rowSums(t)
[1] 22 26 30
> colSums(t)
[1] 6 15 24 33
> rowMeans(t)
[1] 5.5 6.5 7.5

33
> colMeans(t)
[1] 2 5 8 11
Dans le cas d’une table de contingence, les sommes en ligne ou en colonne correspondent aux
distributions marginales en effectif. Il existe une fonction addmargins qui ajoute directement
ces sommes au tableau utilisé :
> addmargins(t)
[,1] [,2] [,3] [,4] [,5]
[1,] 1 4 7 10 22
[2,] 2 5 8 11 26
[3,] 3 6 9 12 30
[4,] 6 15 24 33 78
La fonction prop.table transforme un tableau d’effectifs en proportions. Par exemple :
> prop.table(t)
[,1] [,2] [,3] [,4]
[1,] 0.01282051 0.05128205 0.08974359 0.1282051
[2,] 0.02564103 0.06410256 0.10256410 0.1410256
[3,] 0.03846154 0.07692308 0.11538462 0.1538462
Dans cet exemple, les proportions ont été calculées en divisant chaque valeur du tableau par
la somme totale de toutes les valeurs. Il est possible aussi d’indiquer un second argument,
appelé margin, qui indique une dimension par rapport à laquelle calculer les proportions :
dans le cas d’un tableau bidimensionnel, les valeurs possibles sont 1 et 2 selon qu’on souhaite
les proportions en ligne ou en colonne. Pour une table de contingence, cela permet de cal-
culer les distributions conditionnelles en ligne ou en colonne respectivement. Par exemple,
l’instruction suivante calcule les proportions ligne par ligne :
> prop.table(t,1)
[,1] [,2] [,3] [,4]
[1,] 0.04545455 0.1818182 0.3181818 0.4545455
[2,] 0.07692308 0.1923077 0.3076923 0.4230769
[3,] 0.10000000 0.2000000 0.3000000 0.4000000
On peut vérifier que la somme de chaque ligne est égale à 1 comme on peut s’y attendre :
> rowSums(prop.table(t,1))
[1] 1 1 1
La fonction margin.table fonctionne de manière analogue et calcule les sommes des élé-
ments selon la dimension indiquée dans le second argument (appelé margin). Par exemple :
> margin.table(t,1)
[1] 22 26 30
> margin.table(t,2)
[1] 6 15 24 33
Les résultats obtenus sont les mêmes qu’avec les fonctions rowSums et colSums respecti-
vement.L’intérêt de la fonction margin.table est qu’elle s’applique à des tableaux (objets de
classe array) de dimension quelconque et non pas uniquement aux matrices ou tableau de
contingence.

34
2.9 Les graphiques avec R
2.9.1 Les principales commandes graphiques
Les fenêtres graphiques sont nommées X11 sous UNIX et windows sous Windows. Dans
tous les cas, on peut ouvrir une fenêtre graphique avec la commande x11().
Un fichier graphique est ouvert à l’aide de postscript("mesgraphiques.eps")
ou pdf("mesgraphiques.pdf"). Pour afficher la liste des dispositifs graphiques ouverts, on
utilise dev.list().
Les graphiques seront traces dans le dispositif graphique actif. Pour connaître ce dispo-
sitif, on utilise dev.cur().
Pour le changer, on utilise dev.set(i) qui rend le ième dispositif actif. La fonction dev.off()
ferme le dispositif actif, dev.off(i) ferme le ìeme dispositif.
On peut partitionner la fenêtre graphique active à l’aide des commandes split.screen(x)
(x vecteur) ou layout(m,widths=w,heights=h) (m matrice, w vecteur, h vecteur).
Pour visualiser une fenêtre graphique partitionnée avec layout, on utilise layout.show(n)
où n est le nombre de sous-fenêtres.
Les principales commandes graphiques sont données dans le tableau suivant.

35
 plot(x) Tracer le graphe des valeurs de x ordonnées sur l’axe
des abscisses.
plot(x,y) Tracer le graphe de y en fonction de x.
sunflowerplot(x,y) Idem mais les points superposés sont dessinés sous
forme de fleurs dont le nombre de petales correspond
au nombre de points.
pie(x) Tracer un graphe en camembert.
boxplot(x) Tracer le graphe en "boîtes et moustaches" de x.
stripplot(x) Tracer le graphe des valeurs de x sur une ligne.
interaction.plot(f1,f2,x,fun=mean) Tracer le graphe des moyennes de x en fonction des
valeurs des facteurs f1 (sur l’axe des abscisses) et f2
(plusieurs graphes).
coplot(xỹ|z) Tracer le graphe bivarié de x et y pour chaque valeur
de z.
matplot(x,y) Tracer le graphe bivarié de la 1ère colonne de x contre
la 1ère colonne de y, la 2ème colonne de x contre la
2ème colonne de y...
pairs(x) Si x est une matrice ou un data.frame, tracer tous les
graphes bivariés entre les colonnes de x.
plot.ts(x), ts.plot(x) Tracer le graphe d’une série temporelle x en fonction
du temps.
hist(x,freq=T) Tracer un histogramme des fréquences de x.
barplot(x) Tracer un histogramme des valeurs de x.
qqnorm(x) Tracer les quantiles de x en fonction de ceux attendus
d’une loi normale.
qqplot(x,y) Tracer les quantiles de y en fonction de ceux de x.
contour(x,y,z) Tracer des courbes de niveau.
filled.contour(x,y,z) Idem mais les aires entre les contours sont colorées.
image(x,y,z) Idem mais en couleur.
persp(x,y,z) Idem mais en 3D.
symbols(x,y,...) Dessiner aux coordonnées données par x et y des sym-
boles (etoiles, cercles, boxplots...).

Pour ces fonctions, les options principales sont les suivantes :

36
 axes=TRUE ou FALSE Si TRUE, les axes et le cadre sont traces.
type="n","p","l","b,"h","s"... Précise le type de graphe dessine. type="n" supprime
le graphe.
col="blue", col.axis, col.main... Précise la couleur du graphe, des axes, du titre...
bg="yellow" Précise la couleur du fond.
xlim=c(0,10),ylim=c(0,20) Précise les limites des axes.
xlab="abscisse",ylab="ordonnée" Précise les annotations des axes.
main="titre" Précise le titre du graphe.
sub="sstitre" Précise le sous-titre du graphe.
bty="n","o"... Contrôle comment le cadre est trace. bty="n" sup-
prime le cadre.
cex=1.5, cex.axis, cex.main... Contrôle la taille des caractères.
font=1, font.axis... Précise la police du texte.
las="0" Contrôle comment sont orientees les annotations des
axes.
lty="1" Contrôle le type de lignes tracées.
lwd=1.5 Contrôle la largeur des lignes.
pch="+","o"... Contrôle le type de symbole utilise pour le trace des
points.
ps=1.5 Contrôle la taille en points du texte et des symboles.
tck, tcl Précise la longueur des graduations sur les axes.
mfcol=c(3,2), mfrow=c(3,2) Partitionne le graphe en 3 lignes et 2 colonnes. Les
figures sont remplies colonnes par colonnes ou lignes
par lignes.
Les paramètres ci-dessus peuvent être précisés de manière permanente à l’aide de la
commande par().
Le tableau suivant donné un aperçu des fonctions graphiques secondaires (ayant une
action sur un graphe existant).

37
 points(x,y) Ajouter le graphe des points y en fonction de x.
lines(x,y) Ajouter le graphe de y en fonction de x en trait continu.
text(x,y,labels) Ajouter le texte spécifié par labels aux coordonnées
(x,y).
text(x,y,expression()) Ajouter l’expression mathématique spécifiée par ex-
pression() aux coordonnées (x,y).
text(x,y,as.expression(substitute()) Ajouter une expression mathématique incluant la va-
leur d’une variable numerique aux coordonnées (x,y).
mtext(texte,side=3,...) Ajouter du texte dans la marge specifiee dans side.
segments(x0,y0,x1,y1) Tracer des segments joignant les points (x0,y0) aux
points (x1,y1).
arrows(x0,y0,x1,y1,angle=30,code=1,2 ou 3) Tracer des fleches dont la pointe forme un angle de
30 avec l’axe aux points (x1,y1), (x0,y0) ou aux deux
respectivement.
abline(a,b) Ajouter une ligne d’ordonnée à l’origine a, de pente b.
abline(h=y) Ajouter une ligne horizontale sur l’ordonnée y.
abline(v=x) Ajouter une ligne verticale sur l’abscisse x.
abline(lm.obj) Ajouter la droite de régression donnée par lm.obj.
rect(x1,y1,x2,y2) Tracer un rectangle délimité à gauche par x1, à droite
par x2, en bas par y1, en haut par y2.
polygon(x,y) Tracer un polygone reliant les points de coordonnées
(x,y).
legend(x,y) Ajouter la légende au point de coordonnées (x,y).
title(main,sub) Ajouter un titre, un sous-titre.
axis(side,vect) Ajouter un axe ou des graduations sur les axes.
rug(x) Dessiner les données x sur l’axe des abscisses sous
forme de traits verticaux.
locator(n,type="n",...) Retourner les coordonnées (x,y) ou tracer des sym-
boles aux points de coordonnées (x,y) apres que l’uti-
lisateur ait clique n fois sur le graphe.
text(locator(1), "Point M") Utiliser la souris pour placer du texte.
identify(x,y,labels) Mettre en évidence certains points du graphe à l’aide
du bouton gauche de la souris, leur accoler du texte.

2.10 Graphiques statistiques

Le package graphics R fournit une vingtaine de fonctions qui produisent automatique-
ment des graphiques statistiques classiques, tels que des histogrammes ou des diagrammes à
secteurs circulaires (dits aussi camemberts).

2.10.1 Diagramme en bâtons

Les diagrammes en bâtons sont obtenus au moyen de la fonction barplot dont voici
quelques exemples :

38
 USPersonalExpenditure

1960
20
15

1950
10
5

1940
0

1940 1945 1950 1955 1960 0 5 10 15 20

Medical and Health Medical and Health

border=NA beside=TRUE
150

80
60
100

40
50

20
0

1940 1945 1950 1955 1960 1940 1945 1950 1955 1960

39
> layout(matrix(1:4,nrow=2,byrow=TRUE))
> barplot(USPersonalExpenditure[3,],space=1.5,xlab="Medical and Health")
> barplot(USPersonalExpenditure[3,],space=1.5,horiz=TRUE,
xlab="Medical and Health")
> barplot(USPersonalExpenditure[3,],space=1,border=NA,main="border=NA")
> barplot(USPersonalExpenditure[3,],beside=TRUE,main="beside=NA")
> layout(1)
> title("USPersonalExpenditure")
> layout(matrix(1:4,nrow=2,byrow=TRUE))
> barplot(USPersonalExpenditure[3,],space=1.5,xlab="Medical and Health")
> barplot(USPersonalExpenditure[3,],space=1.5,horiz=TRUE,
xlab="Medical and Health")
> barplot(USPersonalExpenditure[3,],space=1,border=NA,main="border=NA")
> barplot(USPersonalExpenditure[3,],beside=TRUE,main="beside=TRUE")
> layout(1)
> title("USPersonalExpenditure")

Le premier argument est un vecteur ou une matrice. Si c’est un vecteur (comme dans les
deux exemples du haut de la figure précédente), ses valeurs indiquent la hauteur des bâtons.
Si c’est une matrice, chaque colonne de la matrice est traitée comme un vecteur et il y a deux
types de représentations selon la valeur de l’argument logique beside : s’il est égal à FALSE,
chaque bâton correspond à une colonne dont les valeurs sont les hauteurs de sous-bâtons
empilés (figure en bas à gauche) ; s’il est égal à TRUE, les valeurs de chaque colonne sont
juxtaposées et non pas empilées (figure en bas à droite).
L’argument space contrôle l’espacement entre les bâtons. Il est exprimé comme un mul-
tiple ou une fraction de la largeur des bâtons.
La valeur de retour est invisible et contient, sous forme d’une matrice, les abscisses des
milieux de tous les bâtons. Par exemple :

> bp <- barplot(USPersonalExpenditure[3,],space=1.5)

> bp
[,1]
[1,] 2.0
[2,] 4.5
[3,] 7.0
[4,] 9.5
[5,] 12.0

2.10.2 Diagrammes circulaires

Les diagrammes en secteurs circulaires (dits communément camemberts) sont obtenus
au moyen de la fonction pie (anciennement appelée piechart).

> pie(USPersonalExpenditure[,5],radius=0.6,main="USPersonalExpenditure 196

40
 USPersonalExpenditure 1960

Food and Tobacco

Private Education
Personal Care

Medical and Health

Household Operation

41
 L’argument optionnel clockwise indique le sens dans lequel sont dessinés les secteurs :
s’il est égal à TRUE, ils sont représentés dansle sens des aiguilles d’une montre.
L’argument init.angle indique l’angle (en degrés) à partir duquel est dessiné le premier
secteur.
L’argument radius contrôle le rayon du cercle. Sa valeur par défaut est 0, 8.
Cette fonction graphique ne renvoie aucune valeur.

2.10.3 Diagrammes à moustaches

Les diagrammes à moustaches (en anglais whiskers plots ou boxplots) sont obtenus au
moyen de la fonction boxplot. Le premier argument de cette fonction peut être un vecteur
numérique si une seule boîte doit être déssinée ou une formule de la formule y F où y
désigne un vecteur numérique et F un facteur de même longueur que y : dans ce cas, une
boîte est dessinée pour chaque niveau du facteur. Dans les exemples ci-dessous, trois boîtes à
moustaches sont dessinées car le facteur dose du jeu de données ToothGrowth possède trois
niveaux (0,5, 1 et 2).

> pie(USPersonalExpenditure[,5],radius=0.6,
main="USPersonalExpenditure 1960")
> layout(matrix(1:2,nrow=1))
> boxplot(len~dose,data=ToothGrowth,notch=TRUE,xlab="notch=TRUE")
> boxplot(len~dose,data=ToothGrowth,horizontal=TRUE,
xlab="horizontal=TRUE")
> layout(1)
> title("ToothGrowth")

L’argument horizontal contrôle l’orientation des boîtes. Cette fonction renvoie, de manière
invisible, une liste comportant les informations numériques sur les différents groupes de
données.

2.10.4 Histogrammes
Les histogrammes sont obtenus au moyen de la fonction hist. Par défaut, elle prend en
argument un vecteur numérique et applique un algorithme pour décider comment opérer le
découpage permettant de délimiter les rectangles de l’histogramme.

> layout(matrix(1:2,nrow=1))
> x <- rt(200,5)
> hist(x, density=5, angle=30, ylab="Effectifs", xlab="", main="")
> hist(x, prob=TRUE, ylim=c(0,0.5), ylab="Proportions", xlab="",
main="",col="lightgray")
> curve(dt(x,5), add=TRUE, lty=3)
> layout(1)
> title("Student avec 5 d.l.")

42
 ToothGrowth
35
30

2
25
20

1
15
10

0.5
5

0.5 1 2 5 10 15 20 25 30 35

notch=TRUE horizontal=TRUE

43
 ToothGrowth
35
30

2
25
20

1
15
10

0.5
5

0.5 1 2 5 10 15 20 25 30 35

notch=TRUE horizontal=TRUE

44
 Density

0.0 0.1 0.2 0.3 0.4 0.5 0.6

−3
−2
−1

Histogram of x
x

0
1
2
3

On peut imposer directement le découpage au moyen de l’argument breaks dont la valeur

est un vecteur contenant les abscisses des intervalles de base, autrement dit des classes dans
lesquelles sont regroupées les données. Par exemple, pour obtenir un histogramme d’une
variable x avec des rectangles correspondant aux déciles de l’échantillon, on peut utiliser
l’instruction suivante :
> x <- rnorm(500)
> hist(x, breaks=quantile(x, probs=0:10/10))
L’argument optionnel probability prend une valeur logique (TRUE or FALSE) et indique
si les valeurs portées sur l’axe vertical sont exprimées en proportion (valeur TRUE) ou en
effectifs (valeur FALSE). Alternativement, on peut utiliser l’argument frep qui est l’opposé
de probability.
Les deux graphiques précédents représentent l’histogramme d’un échantillon distribué
selon la loi de Student à 5 degrés de liberté. La figure de gauche donne un exemple d’utili-
sation des options density et angle. La figure de droite dessine les données en proportions

45
(renvoyée sous forme invisible) est un objet de classe histogram qui comporte des infor-
mations sur les coordonnées des rectangles et le nombre de valeurs qu’ils contiennent. Par
exemple :

> names(hist(x))
[1] "breaks" "counts" "intensities" "density" "mids"
[6] "xname" "equidist"

2.10.5 Diagrammes matriciels

Les diagrammes matriciels sont des diagrammes multiples qui sont organisés selon une
grille matricielle. Ils correspondent souvent à des couples de variables qui sont observées se-
lon différents niveaux d’un facteur ou qui sont extraites deux à deux d’un tableau de données
ou d’une matrice.

La fonction pairs La fonction pairs prend en général un argument x qui est un tableau de
données ou une matrice dont les colonnes représentent des valeurs numériques. Son compor-
tement par défaut consiste à dessiner des diagrammes de dispersion pour chaque couple de
variables : le graphique situé sur la ligne i et la colonne j de la grille matricielle (avec i 6= j)
représente la valeur x[, i] (i-ème colonne de x) en fonction de x[, j] (j-ème colonne de x).

46
Chapitre 3

Tests paramétriques et non

paramétriques

3.1 Modèle linéaire multiple

R possède un nombre important de fonctions pour la modélisation statistique, c’est-à-dire
la recherche de modèles qui rendent compte de variables observées et de leurs relations, et
pour la simulation de ces modèles. Le plus célèbre de tous les modèles qui existent est certai-
nement le modèle linéaire et nous présentons dans cette section les principales commandes
disponibles pour l’utiliser.

3.1.1 Rappels théoriques

Dans sa forme la plus simple, le modèle linéaire cherche à établir une relation de la
forme :
Y = β0 + β1 X1 + β2 X2 + · · · + βm Xm + ε (3.1)
où Y désigne la réponse (ou variable expliquée ou endogène) et X1 , X2 , . . . , Xm désignent
les prédicteurs (ou variables explicatives ou exogènes).
Les termes β0 , β1 , . . . , βm s’appellent les cœfficients du modèle : ce sont les valeurs à
estimer. La recherche de ces cœfficients est souvent appelée régression linéaire.
Y, X1 , X2 , . . . , Xm et ε sont des vecteurs à N coordonnées représentant des échantillons
de taille N . Le vecteur ε représente les erreurs ou les perturbations du modèle. La relation
(3.1) peut s’écrire sous la forme matricielle :

Y = Xβ + ε (3.2)

avec
Les formes linéaires ne comportent pas nécessairement de terme constant (c’est-à-dire de
paramètre β0 ). Si ce terme constant est requis par le modèle, le vecteur β comportera m + 1
cœfficients. Si on recherche un modèle sans terme constant, le vecteur β ne comportera que
m cœfficients. Formellement, cela ne change en rien les formules : la seule différence est
la présence ou pas d’une première colonne de 1 dans la matrice X. Dans la suite de cette
section, on désignera par p le nombre de paramètres du modèle (m ou m + 1).

47
 On utilise en général, pour estimer les cœfficients β, la méthode des moindres carrés qui
consiste à minimiser la somme des carrés des erreurs :
X
ε2i = tε · ε = t (Y − Xβ) (Y − Xβ) .

Mathématiquement, on montre que la solution βb vérifie la relation tXX βb = tXY . En suppo-

sant que la matrice carrée tXX est inversible, on obtient :

−1 t
βb = tXX XY. (3.3)

On note par Yb le vecteur X β.

b Ce vecteur Yb représente les valeurs estimées par le modèle.
On les appelle aussi valeurs ajustées (en anglais fitted values). On a donc :

−1 t
Yb = X βb = X tXX XY = HY (3.4)
−1
La matrice H = X (tXX) tX est appelée la matrice chapeau (en anglais hat matrix).
La différence entre les valeurs observées Y et les valeurs ajustées Yb s’appelle résidus et
est notée εb. On a, en notant I la matrice unité :
εb = Y − Yb = Y − HY = (I − H) Y. (3.5)
Les hypothèses statistiques usuelles du modèle linéaire consistent à supposer que les erreurs
peuvent être assimilées à un bruit blanc, c’est-à-dire à un processus de moyenne nulle, de
variance constante (égale à σε2 ) et non autocorrélé. Sous ces hypothèses, on peut calculer
l’espérance et la variance du vecteur aléatoire βb :
b = σ 2 tXX −1 .


E(β)
b = β et V ar(β)
ε (3.6)
Si on note :
P 2
• SCR = εbi la somme des carrés des résidus, on montre que σ bε2 = SCR/(N − p)
est un estimateur de la variance σε2 . La variance de cet estimateur est donnée par la
formule V ar(b ε) = σε2 (I − H).
• SCT la somme totale des carrés des écarts à la moyenne pour la variable Y ,
• SCE la somme des carrés des écarts pour les valeurs ajustées Yb
Ces quantités sont reliées par la formule suivante :
SCT = SCE + SCR.
Le rapport entre SCE et SCT représente la proportion de variance expliquée et porte le nom
de cœfficient de détermination ou de cœfficient R2 :
SCE SCR
R2 = =1− . (3.7)
SCT SCT
Le cœfficient R2 est compris entre 0 et 1 : plus il est proche de 1 et plus grande est la
part expliquée par le modèle obtenu. On définit aussi un cœfficient R2 corrigé (en anglais
adjusted) qui tient compte des degrés de liberté. Ce cœfficient, noté Ra2 , est donné par :
SCR/(N − p)
Ra2 = 1 − . (3.8)
SCT /(N − 1)
L’exemple suivant est tiré de Husson.

48
Exemple 3.1.1.

# 1. Importer les données

‘‘‘{r ozone}
ozone <- read.table("https://r-stat-sc-donnees.github.io/ozone.txt",header
ozone.m <- ozone[,1:11]
summary(ozone.m)
‘‘‘

# 2. Représenter les variables

‘‘‘{r}
pairs(ozone.m[,1:4])
‘‘‘

# 3. Estimer les paramètres

‘‘‘{r}
reg.mul <- lm(maxO3~., data=ozone.m)
summary(reg.mul)
‘‘‘

# 4. Choix de variables

‘‘‘{r,warning=FALSE,message=FALSE}
library(leaps)
choix <- regsubsets(maxO3~.,data=ozone.m,nbest=1,nvmax=11)
plot(choix,scale="bic")
‘‘‘

‘‘‘{r}
reg.fin <- lm(maxO3~T12+Ne9+Vx9+maxO3v,data=ozone.m)
summary(reg.fin)
‘‘‘

# 5. Analyser les résidus

‘‘‘{r}
res.m <- rstudent(reg.fin)
plot(res.m,pch=15,cex=.5,ylab="Résidus",main="",ylim=c(-3,3))
abline(h=c(-2,0,2),lty=c(2,1,2))
‘‘‘

# 6. Prévoir une nouvelle valeur

49
‘‘‘{r}
xnew <- matrix(c(19,8,2.05,70),nrow=1)
colnames(xnew) <- c("T12","Ne9","Vx9","maxO3v")
xnew <- as.data.frame(xnew)
predict(reg.fin,xnew,interval="pred")
‘‘‘

50
Chapitre 4

Analyse de la variance à un facteur

— introduire le vocabulaire de la théorie de l’ana-

lyse de la variance
— présenter le modèle statistique associé à l’ana-
lyse de la variance
Objectifs de ce chapitre
— mettre en place le test de Fisher
— mettre en place le test des comparaisons mul-
tiples
— calculer les puissances des tests

4.1 Introduction
4.1.1 Objectif
L’analyse de la variance utilise un vocabulaire spécifique : les variables qualitatives sus-
ceptibles d’influer sur la distribution de la variable quantitative étudiée sont appelées fac-
teurs (ou facteurs de variabilité ) et leurs modalités, niveaux. Dans ce chapitre, les facteurs
sont toujours contrôlés, c’est-à-dire fixés par l’expérimentateur.
L’analyse de la variance permet de comparer les espérances de variables aléatoires in-
dépendantes qui suivent des lois normales de même variance sur plusieurs populations.
Cette méthode permet la comparaison de K moyennes et peut donc être vue comme une
extension du test de comparaison de moyennes.

4.1.2 Exemple : Rendement et variété de maïs, quel problème ?

Une importante entreprise agro-alimentaire cherche à optimiser le rendement de ses plan-
tations de maïs. Trois variétés de maïs sont testées et plantées sur dix parcelles de deux
hectares. Les rendements obtenus figurent dans le tableau suivant :
Le responsable de l’étude se demande si la variété de maïs a une influence sur le rende-
ment. Le problème est simplifié : il s’agit de tester si le rendement moyen est différent selon
la variété de maïs utilisée.

51
 TABLE 4.1 – Rendements en quintaux des parcelles de maïs
Variété 1 Variété 2 Variété 3
206 206 181
205 218 199
199 192 194
187 207 190
193 196 200
183 187 205
198 197 199
201 186 193
180 212 213
213 190 199
x̄1 = 196.5 x̄2 = 199.1 x̄3 = 197.3

4.2 Modélisation statistique

4.2.1 Définitions et notations
Définition 4.2.1. Pour chaque mesure, deux variables sont observées :
1. Le facteur de variabilité est la variable qualitative “variété de maïs”. Ce facteur a
trois niveaux simplement appelés variété1, 2 ou 3. Le facteur “variété de maïs” est
totalement contrôlé par l’expérimentateur et est donc à effets fixes.
2. La variable quantitative étudiée est le rendement de la plantation. Elle est appelée la
réponse.

Notations :
— La variable mesurée à l’issue d’une telle expérience est notée Y.
— Pour les observations, deux indices sont utilisés :
• le premier indice indique le numéro du groupe dans la population (“Variété”), noté
en général i ;
• le second indice indique le numéro de l’observation dans chacun des groupes qui
composent l’échantillon (“parcelle”), noté en général j.
— Les observations sont en général notées par yi,j où i varie de 1 à I et j de 1 à ni .

Définition 4.2.2. Lorsque les échantillons sont tous de même taille, c’est-à-dire ni = J pour
i variant de 1 à I, l’expérience est dite équilibrée.

Remarque 4.2.1. 1. Lorsque l’expérience est équilibrée, l’effectif total n est égal à IJ.
2. Lorsque les effectifs des échantillons sont très différents, les différences qu’il est pos-
sible de détecter sont supérieures à celles d’une expérience équilibrée qui aurait le
même effectif total. L’analyse est donc moins performante.

52
Seul le plan équilibré sera détaillé par la suite mais les logiciels de statistique vous
permettent d’analyser aussi des expériences déséquilibrées .

Définition 4.2.3. En se plaçant dans le cas équilibré, les moyennes de chaque échantillon
sont définies et notées par :
J
1X
ȳi = yi,j , i = 1, . . . , I,
J j=1

et les variances empiriques corrigées de chaque échantillon par :

J
1 X
s2ci (y) = (yi,j − ȳi )2 , i = 1, . . . , I.
J − 1 j=1

Retour à l’exemple des parcelles : Les lignes de commande ci-dessous vont vous per-
mettre de calculer les quantités évoquées ci-dessus. Il faut d’abord commencer par rentrer
les données sous R. Pour cela taper les lignes de commandes suivantes :

> parcelle <- rep(1:3,c(10,10,10))

> rendement <- c(206,205,199,187,193,183,198,201,180,213,
206,218,192,207,196, 187,197,186,212,190,181,199,194,190,
200,205,199,193,213,199)
> parcelle <- factor(parcelle)
> plantation <- data.frame(parcelle,rendement)
> rm(parcelle)
> rm(rendement)
> plantation

Pour obtenir les moyennes de chaque échantillon, vous tapez les lignes de commandes sui-
vantes :

> moyennes <- tapply(plantation$rendement,plantation$parcelle,mean)

> moyennes

Pour obtenir les variances corrigées dans chaque échantillon, vous tapez les deux lignes
de commande suivantes :

> variances <- tapply(plantation$rendement,plantation$parcelle,var)

> variances

4.2.2 Modèle statistique

Le modèle statistique, dans le vas équilibré, s’écrit sous la forme suivante :

Yi,j suit la loi N (µi ; σ) , pour i = 1, . . . , I et j = 1, . . . , J

53
où µi désigne l’espérance dans la population i. Ainsi vous constatez que, si les lois des
variables Yi,j sont différentes, elles ne peuvent différer que par leur espérance. Il y a donc un
simple décalage entre elles.
Le plus souvent, ce modèle statistique est écrit de la façon suivante :

Yi,j = µ + αi + εi,j

où les variables εi,j suivent la loi normale N (0; σ) pour i = 1, . . . , I et j = 1, . . . , J et les

αi vérifient la contrainte
X I
αi = 0.
i=1

Vous avez donc la correspondance :

µi = µ + α i pour i = 1, . . . , I.

4.2.3 Conditions fondamentales

Vous supposez que les variables d’erreur εi,j satisfont les trois conditions suivantes :
1. Les variables εi,j sont indépendantes.
2. Les variables εi,j ont toutes la même variance inconnue σ 2 . C’est la condition
d’homogénéité des variances ou d’homoscédasticité.
3. Les variables εi,j suivent la loi normale centrée et de variance σ 2 .

4.3 Test de comparaison de plusieurs espérances

Vous désirez choisir entre les deux hypothèses suivantes :

H 0 : µ1 = µ2 = · · · = µI
contre

H1 : Les espérances µi ne sont pas toutes égales.

ou de manière équivalente :

H0 : α1 = α2 = · · · = αI
contre

H1 : Les effets αi ne sont pas tous nuls.

La méthode qui permet de procéder à ce choix, à l’aide d’un test, est appelée l’analyse de la
variance. Le cas détaillé dans la suite reste le cas équilibré.

54
4.3.1 Deux propriétés fondamentales
Le test est fondé sur deux propriétés :
- Première propriété : La moyennes de toutes les observations est la moyenne des moyennes
de chaque échantillon. Ceci s’écrit :
J I I J I
1 XX 1 XX 1X
ȳn = yi,j = yi,j = ȳi .
n j=1 i=1 n i=1 j=1 I i=1

Remarque 4.3.1. Vous pouvez vérifier cette propriété sur l’exemple des parcelles.
En tapant la ligne de commande suivante :
> moy.g <- mean(plantation$rendement)
> moy.g
qui est aussi égale à :
> mean(moyennes)
- Deuxième propriété : La variance de toutes les observations est la somme de la va-
riance non corrigée des moyennes et de la moyennes des variances non corrigées.
Ceci s’écrit :
I J I I
1 XX 1X 1X 2
s2 (y) = (yi,j − ȳn )2 = (ȳi − ȳn )2 + s (y). (4.1)
n i=1 j=1 I i=1 I i=1 i

Remarque 4.3.2. Vérifier cette égalité en vous servant des données de l’exemple des plan-
tations.

Retour à l’exemple des plantations : Le test porte sur la comparaison des espérances. À
cette étape, il serait bon de tracer les boîtes à moustaches de la variable RENDEMENTS en
fonctions de la variable PARCELLE. Pour, cela tapez les lignes de commande suivantes :

> plot(plantation$parcelle,plantation$rendement)
> points(1:3,moyennes,pch="@")
> abline(h=moy.g)

4.3.2 Le résultat fondamental de l’analyse de la variance

En multipliant les deux membres de l’équation (4.1) par n, vous obtenez :
I X J I I J
!
X X X X
(yi,j − ȳn )2 = J (ȳi − ȳn )2 + (yi,j − ȳi )2 . (4.2)
i=1 j=1 i=1 i=1 j=1

ou encore ce qui s’écrit :

SCtot = SCf ac + SCres .

55
Définition 4.3.1. La variation totale est le terme défini par :
I X
X J
SCtot = (yi,j − ȳn )2 .
i=1 j=1

Elle indique la dispersion des données autour de la moyenne générale.

Définition 4.3.2. La variation due au facteur est le terme défini par :

I
X
SCf ac = J (ȳi − ȳn )2 .
i=1

Elle indique la dispersion des moyennes autour de la moyenne générale.

Définition 4.3.3. La variation résiduelle est le terme défini par :

I J
!
X X
SCres = (yi,j − ȳi )2 .
i=1 j=1

Elle indique la dispersion des données à l’intérieur de chaque échantillon autour de sa

moyenne.

Définition 4.3.4. Le carré moyen dû au facteur est le terme défini par

CMf ac = SCf ac /(I − 1).

Définition 4.3.5. Le carré moyen résiduel est le terme défini par

CMres = SCres /(n − 1).

Si les variables d’erreur εi,j sont indépendantes et de même variance σ 2 , le carré moyen
résiduel est une estimation sans biais de cette variance σ 2 .

4.3.3 Test de l’analyse de la variance

Conditions d’application du test :
Les trois conditions fondamentales d’application du test sont détaillées au paragraphe
Conditions fondamentales.

Hypothèses du test :

H0 : µ1 = µ2 = · · · = µI
contre

H1 : Les espérances µi ne sont pas toutes égales.

56
ou de manière équivalente :

H0 : α1 = α2 = · · · = αI
contre

H1 : Les effets αi ne sont pas tous nuls.

Statistique du test :
Si les trois conditions fondamentales sont satisfaites et si l’hypothèse nulle H0 est véri-
fiée, alors la variable
CMf ac
F (obs) =
CMres
est une réalisation de la variable aléatoire F qui suit la loi de Fisher F (I − 1; n − I).

Décision et conclusion du test :

Pour un seuil α donné, des tables de la loi de Fisher vous fournissent une valeur critique
cα telle que
P (F ≤ cα ) = 1 − α.
Alors vous décidez : 
H0 est vraie si F (obs) < cα ,
H1 est vraie si F (obs) ≥ cα .
Vous pouvez aussi raisonner avec la p-valeur, comme dans les autres tests vus précédemment.
Plusieurs fonctions du logiciel R permettent de réaliser ce test :
— ANOVA appliquée à un objet produit par LM ;
— SUMMARY utilisée sur un objet produit par AOV.

4.3.4 Tableau de l’analyse de la variance

Définition 4.3.6. Le tableau de l’analyse de la variance résume l’ensemble de la procédure.
Sources de Somme Degrés de Carrés F(obs) Fcritique
variation des carrés liberté moyens
CMf ac
Due au SCf ac I-1 CMf ac CMres
cα
facteur
Résiduelle SCres n-I CMres
Totale SCtot n-1

Retour à l’exemple des plantations de maïs : Vous devez commencer par indiquer au
logiciel R qu’il doit utiliser la même contrainte sur les paramètres du modèle. Dans le cas
équilibré celle-ci s’écrit α1 + α2 + · · · + αI = 0. Avant de débuter n’importe quelle analyse
de la variance, vous éxecuterez toujours la ligne de commande :

> options(contrasts=c("contr.sum","contr.poly"))

57
Pour obtenir le tableau de l’analyse de la variance en utilisant les fonctions ANOVA et LM, il
faut taper les deux lignes de commande suivantes :
> modele1=lm(rendement~parcelle,data=plantation)
> anova(modele1)
Pour obtenir le tableau de l’analyse de la variance en utilisant les fonctions AOV et SUM -
MARY ,il faut taper les deux lignes de commande suivantes :
> modele1_aov=aov(rendement~parcelle,data=plantation)
> anova(modele1_aov)
Pour indiquer à R que, dans le cas équilibré, les estimations des effets αi de chaque groupe
doivent être de somme nulle, vous devez exécuter la commande :
> options(contrasts=c("contr.sum","contr.poly"))

4.4 Vérification des trois conditions fondamentales et conclu-

sion
4.4.1 Condition d’indépendance
Il n’existe pas, dans un contexte général, de test statistique simple permettant d’étu-
dier l’indépendance. Ce sont les conditions de l’expérience qui vous permettront d’affirmer
que cette condition est remplie.

4.4.2 Condition de normalité

Vous ne pourrez pas, en général, la tester pour chaque échantillon. En effet le nombre
d’observations est souvent très limité pour chaque échantillon. Vous allez donc la tester sur
l’ensemble des données.
Si les trois conditions fondamentales sont satisfaites et si vous notez :
εi,j = Yi,j − µi ,
alors les variables εi,j suivent toutes la même loi N (0, σ).
Vous cherchez à calculer les réalisations des variables d’erreur εi,j sur l’échantillon. Pour
cela vous devez connaître la valeur observée yi,j et les espérances µi . Ces dernières étant
J
X
1
inconnues, vous les estimez avec les estimateurs de la moyenne Ȳi avec Ȳi = J Yi,j . Vous
j=1
en déduisez les estimations ȳi .
Définition 4.4.1. Les quantités suivantes, notées ebi,j et définies par :
ebi,j = yi,j − ȳi , pour i = 1, . . . , I, et j = 1, . . . , J,
s’appellent les résidus.
Vous désirez tester la normalité des variables d’erreur εi,j avec le test de Shapiro-Wilk.
Vous utilisez l’échantillon formé par les résidus pour réaliser ce test.

58
Hypothèses du test :

H0 : Les variables d’erreur εi,j suivent une loi normale

contre

H1 : Les variables d’erreur εi,j ne suivent pas une loi normale.

Conditions d’application du test :

Ce test nécessite l’indépendance des variables d’erreur.

Statistique de test
La statistique du test de Shapiro-Wilk :—-

Décision et conclusion du test :

Vous utiliserez la p-valeur donnée par R ou un autre logiciel de statistique pour conclure.
Des études ont montré que, lorsque l’effectif de l’échantillon est supérieur ou égal à 30, la
puissance du test de Shapiro-Wilk est acceptable.

Retour à l’exemple des plantations : Avec le logiciel R, en tapant les deux lignes de
commande suivantes :

> residus <- residuals(modele1)

> shapiro.test(residus)

La p-valeur étant strictement supérieure à α = 5%, le test n’est pas significatif.Vous décidez
de conserver l’hypothèse nulle H0 . Le risque d’erreur associé à cette décision est un risque
de deuxième espèce. Vous ne pouvez pas l’évaluer dans le cas présent. Vous décidez donc
que l’hypothèse de normalité des variables d’erreur est satisfaite.

4.4.3 Conditions d’homogénéité des variances

Plusieurs tests permettent de tester l’égalité de plusieurs variances. Parmi ceux-ci, le test
le plus utilisé est le test de Bartlett dont le protocole est le suivant :

Hypothèses du test :

H0 : σ12 = σ22 = · · · = σI2

contre

H1 : Les variances σi2 ne sont pas toutes égales.

59
Conditions d’application du test :
Ce test nécessite la normalité et l’indépendance des variables dont les variances sont
comparées.

Statistique de test :
Une réalisation de la statistique de test de Bartlett, pour des plans équilibrés ou non, est
égale à " #
I
1 X
(ni − 1) ln s2c,i


B(obs) = (n − I) ln (CMres ) −
C1 i=1

— la quantité C1 est définie par

I
! !
1 X 1 1
C1 = 1 + − ,
3(I − 1) i=1
ni − 1 n−I

— CMres le carré moyen résiduel et s2c,i la variance corrigée de l’échantillon d’ordre i.

Si l’hypothèse H0 est vérifiée, alors la variable Bobs est une réalisation de la variable aléatoire
B qui suit asymptotiquement la loi du χ2 (I − 1).
En pratique, vous pouvez l’appliquer lorsque les effectifs ni des I échantillons sont tous
au moins égaux à trois.

Décision et conclusion du test :

Pour un seuil α donné, des tables de la loi du Khi-deux vous fournissent une valeur
critique cα telle que
P (B ≤ cα ) = 1 − α.
Alors vous décidez : 
H0 est vraie si B(obs) < cα ,
H1 est vraie si B(obs) ≥ cα .
La fonction sous R qui permet de réaliser ce test est la fonction BARTLETT. TEST. Il vous
recommandé de consulter l’aide pour savoir comment il faut la paramétrer.
Retour à l’exemple des plantations :
En tapant la ligne de commande suivante :

> bartlett.test(residus~parcelle,data=plantation)

La p-valeur étant strictement supérieure à α = 5%, le test n’est pas significatif. Vous conser-
vez l’hypothèse nulle H0 avec un risque d’erreur de deuxième espèce qu’il faudrait évaluer.
Vous décidez donc que l’hypothèse d’égalité des variances est satisfaite.

60
4.4.4 Et si les conditions ne sont pas vérifiées que faire ?
Dans le cas où les conditions ne sont pas vérifiées, il vous faut alors envisager un test
non paramétrique. L’esprit du test de Kruskal-Wallis est similaire à celui de l’analyse de la
variance : il permet de détecter des décalages entre les différentes populations lorsque les va-
riances des différentes populations sont égales. Pour vérifier l’ǵalité des variances sans avoir
à faire une hypothèse de normalité,vous pourrez par exemple utiliser le test non paramétrique
de Levene disponible avec la fonction LEVENE . TEST dans la bibliothèque CAR.
La fonction sous R qui permet de réaliser le test de K RUSKAL -WALLIS est la fonction
KRUSKAL . TEST .

4.4.5 Conclusion de l’analyse de la variance

Retour à l’exemple des plantations : Pour obtenir une estimation des paramètres µ, α1 ,
α2 et α3 du modèle par la méthode des moindres carrés, qui est valable dès que les condi-
tions d’indépendance et d’homogénéité des variances sont vérifiées, vous pouvez exécuter la
commande

> coef(modele1)
(Intercept) parcelle1 parcelle2
197.633333 -1.133333 1.466667

> -sum(coef(modele1)[2:3])
[1] -0.3333333

En fait les trois conditions fondamentales sont remplies car la condition de normalité est
également vérifiée, vous pouvez donc procéder au test de Fisher de l’analyse de la variance.
Comme la p-valeur du tableau est supérieure à α = 5%, le test n’est pas significatif. Vous ac-
ceptez H0 . Il n’y a donc pas une différence entre les espérances du rendement des plantations
selon le type de parcelles.

61