Une introduction `a R

Transcription

Une introduction à R
Notes sur R: Un Environnement de programmation pour l’Analyse des Données
Version 1.5.0 (2002-04-29)
W. N. Venables, D. M. Smith
et le R Development Core Team
Copyright
Copyright
Copyright
Copyright
Copyright
c
c
c
c
c
1990 W. N. Venables
1992 W. N. Venables & D. M. Smith
1997 R. Gentleman & R. Ihaka
1997, 1998 M. Maechler
1999–2002 R Development Core Team
c 2002, M. Ros pour la traduction française
Copyright Copier et distribuer des copies de ce manuel est autorisé à condition que cette permission
et le copyright soient distribués sur toutes les copies.
Copier et distribuer des versions modifiées de ce manuel est autorisé à condition que la
totalité du travail résultant soit distribuée avec une permission identique à celle-ci.
Copier et distribuer des traductions de ce manuel est autorisé aux conditions données cidessus pour les versions modifiées avec, de plus, l’approbation du R Development Core
Team pour la traduction de la présente permission.
ISBN 3-901167-55-2
i
Table des matières
Préface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1
Introduction et préliminaires . . . . . . . . . . . . . . . 2
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
L’environnement R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Logiciels apparentés à R et documentation . . . . . . . . . . . . . . . .
R et les statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
R et le gestionnaire de fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . .
Utiliser R de façon interactive . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Une session d’introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accèder à l’aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Les commandes de R; la casse etc. . . . . . . . . . . . . . . . . . . . . . . . .
Rappel et correction de commandes . . . . . . . . . . . . . . . . . . . . . . .
Exécuter des commandes depuis un fichier; Rediriger des
sorties vers un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.11 Durée de vie des données; Effacer de objets. . . . . . . . . . . . . . .
2
2
2
2
3
3
4
4
4
5
5
5
Manipulations de base; nombres et vecteurs
......................................... 7
2.1
2.2
2.3
2.4
2.5
2.6
2.7
Vecteurs et affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Opérations sur les vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Générer des séquences de nombres . . . . . . . . . . . . . . . . . . . . . . . . 9
Vecteurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Vecteurs de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Vecteurs indices; sélectionner et modifier des parties d’un jeu
de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.8 Autres types d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3
Objets; leurs modes et attributs . . . . . . . . . . . 14
3.1
3.2
3.3
3.4
4
Attributs intrinsèques : mode et longueur . . . . . . . . . . . . . . . .
Changer la longueur d’un objet . . . . . . . . . . . . . . . . . . . . . . . . . .
Obtenir et modifier des attributs . . . . . . . . . . . . . . . . . . . . . . . .
La classe d’un objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
15
15
16
Facteurs ordonnés et non-ordonnés . . . . . . . . 17
4.1
4.2
4.3
Exemple spécifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
La fonction tapply et les tableaux irréguliers . . . . . . . . . . . . . 17
Facteurs ordonnés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
ii
5
Listes et data frames . . . . . . . . . . . . . . . . . . . . . . 19
5.1
5.2
Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Construire et modifier des listes . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Concatèner des listes . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Data frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Construire des data frames . . . . . . . . . . . . . . . . . . . . .
5.3.2 attach() et detach() . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.3 Travailler avec les data frames . . . . . . . . . . . . . . . . . .
5.3.4 Attacher des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.5 Gérer le search path . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
Lire des données dans des fichiers . . . . . . . . . . 23
6.1
6.2
6.3
La fonction read.table() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
La fonction scan() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Accèder aux jeux de données de base . . . . . . . . . . . . . . . . . . . .
6.3.1 charger des données d’autres packages . . . . . . . . . . .
6.4 Editer des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5 Importer des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
23
24
25
25
25
26
Complément sur le langage. Boucles et
exécution conditionnelle. . . . . . . . . . . . . . . . . . 27
7.1
7.2
8
19
20
20
20
20
21
22
22
22
Expressions groupées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Les instructions de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7.2.1 Exécution conditionnelle : l’instruction if. . . . . . . 27
7.2.2 éxecution repetitive : les boucles for, repeat et while.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Ecrire des fonctions . . . . . . . . . . . . . . . . . . . . . . . 29
8.1
8.2
8.3
8.4
8.5
Exemples simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Définir de nouveaux opérateurs binaires . . . . . . . . . . . . . . . . . .
Arguments nommés et arguments par défaut . . . . . . . . . . . . .
L’argument ‘...’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Affectations dans les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
29
29
29
29
iii
9
Procèdures graphiques . . . . . . . . . . . . . . . . . . . . 30
9.1
9.2
9.3
9.4
9.5
9.6
Commandes graphiques de haut niveau . . . . . . . . . . . . . . . . . . 30
9.1.1 La fonction plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
9.1.1.1 graphes de données multivariées . . . . . . . . 31
9.1.2 Graphiques spéciaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
9.1.3 Arguments des fonctions graphiques de haut niveau
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Fonctions graphiques de bas niveau . . . . . . . . . . . . . . . . . . . . . . 33
9.2.1 Annotation mathématique . . . . . . . . . . . . . . . . . . . . . . 35
9.2.2 Polices Hershey vectorielles . . . . . . . . . . . . . . . . . . . . . 35
Interragir avec les graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Paramètres graphiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
9.4.1 Changements permanents : la fonction par() . . . . . 37
9.4.2 Changements temporaires : arguments des fonctions
graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Liste des paramètres graphiques . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.5.1 Eléments graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
9.5.2 Axes et marques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
9.5.3 Marges des figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9.5.4 Matrices de graphiques . . . . . . . . . . . . . . . . . . . . . . . . . 41
9.5.5 Pilotes de périphériques . . . . . . . . . . . . . . . . . . . . . . . . 41
9.5.6 Diagrammes postscript . . . . . . . . . . . . . . . . . . . . . . . . . 41
Graphiques dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Annexe A
Une session d’introduction à R . . . . 42
Annexe B
Index des variables et fonctions . . . 46
Annexe C
Index des concepts . . . . . . . . . . . . . . . 48
Annexe D
Références . . . . . . . . . . . . . . . . . . . . . . . 49
Préface
1
Préface
Ce document est la traduction française de An introduction to R.
Cette traduction est actuellement en cours néanmoins, si vous prenez le temps de lire
ces pages et de m’envoyer un commentaire ([email protected]), je vous en serais très
reconnaissant.
Les tournures et les choix pour la traduction du vocabulaire spécifique à R sont sujets à
discussion : toutes les propositions ou remarques sont les bienvenues.
J’essaie d’ores et déjà de structurer le document, ne vous étonnez donc pas de trouver
vides certains chapitres et sous-chapitres.
Mathieu Ros
Juin, 2002.
Chapitre 1: Introduction et préliminaires
2
1 Introduction et préliminaires
1.1 L’environnement R
R est un système logiciel pour la manipulation de données, les calculs et la représentation
graphique. Entre autres choses, il offre
•
•
•
•
•
la possibilité de stocker et manipuler des données de façon fiable et efficace.
une grande varièté de fonctions pour l’analyse des données.
une suite d’opérateurs pour les calculs sur les tableaux et matrices.
la possibilité de faire des représentations graphiques pour l’analyse statistique.
un langage de programmation (S) développé, simple et efficace qui inclut conditions,
boucles, fonctions récursives, entrées sorties. La plupart des fonctions sont d’ailleurs
elles-même écrites en S.
On définit R comme un "environnement" car, tout en restant cohérent, il est avant tout
extensible et modifiable. R n’est pas une collection figée d’outils, comme c’est le cas de
beaucoup de logiciels statistiques.
R doit plutôt être vu comme un outil pour développer de nouvelles méthodes d’analyse
de données. De ce fait, il est dynamique et les nouvelles versions ne sont pas toujours
complètement compatibles avec les anciennes. Certains utilisateurs accueillent favorablement ces changements à cause du gain en nouvelles méthodes et techniques apportées par
les nouvelles versions. D’autres sont plus inquiets du fait que certains codes sont à revoir.
Bien que R soit (aussi) un langage de programmation, on doit considèrer la plupart des
programmes que l’on écrit comme éphémères.
1.2 Logiciels apparentés à R et documentation
On peut voir en R une implémentation du langage S qui a été développé à AT&T par
Rick Becker, John Chambers et Allan Wilks, et qui forme également la base du système
S-Plus.
L’évolution du langage S est caractèrisée par quatre livres de John Chambers et coauteurs. La Référence de base pour R est The New S Language: A Programming Environment
for Data Analysis and Graphics par Richard A. Becker, John M. Chambers and Allan R.
Wilks. Les nouveautés apparues avec la version de S de 1991 (Sversion 3) sont traitées dans
Statistical Models in S edité par John M. Chambers et Trevor J. Hastie. Voir Annexe D
[References], page 49, pour des références plus précises.
De plus, on peut utiliser la documentation de S/S-Plus pour R, en gardant à l’esprit
qu’il y a différentes implémentations de S.
1.3 R et les statistiques
On n’a pas encore parlé de statistiques dans cette introduction à R, alors que de nombreuses personnes l’utilisent comme un logiciel statistique. Nous préfèrons voir en R un environnement dans lequel de nombreuses techniques statistiques, classiques et modernes, ont
3
été implémentées. Certaines sont intègrées à l’environnement R de base mais beaucoup sont
disponibles sous forme de packages (la distinction est plus historique qu’autre chose). Il y a
8 packages (ou bibliothèques) fournis avec R (et appelés packages "standards") et beaucoup
d’autres sont disponibles sur l’un des sites du CRAN (via http://www.r-project.org). la
plupart des statistiques classiques et des dernières techniques sont disponibles dans R mais
les utilisateurs seront parfois amenés à faire quelques efforts pour les trouver.
Il y a une importante différence de philosophie entre S (et donc R) et les principaux
autres systèmes statistiques. En S une analyse statistique se fait en une série d’étapes avec
stockage des résultats intermédiaires dans des objets. SAS et SPSS donneront de copieuses
sorties pour une régression ou une analyse discriminante alors que R donnera un minimum
de sorties et stockera les résultats dans un objet pour consultation ultérieure par d’autres
fonctions.
1.4 R et le gestionnaire de fenêtres
La façon la plus agréable d’utiliser R est sur une machine avec gestionnaire de fenêtres.
On se référera en particulier à l’usage de R sur un système X window, même si la plupart
de ce qui est dit s’applique à toutes les implémentations de l’environnement R. Les utilisateurs peuvent, de temps en temps, vouloir interagir directement depuis R avec le système
d’exploitation. Dans ce manuel, on se regardera principalement les interactions avec le
système UNIX. Si vous faites tourner R sous MS-Windows, vous devrez faire quelques
ajustements.
1.5 Utiliser R de façon interactive
R affiche une invite lorsqu’il attend des commandes. L’invite par défaut est ‘>’, ce qui
peut-être la même chose que votre invite shell sous UNIX . Cependant, comme nous le
verrons plus loin, il est facile de changer d’invite si cela vous gène. On considèrera par la
suite que l’invite shell est ‘$’. Quand on est sous UNIX, la procèdure à suivre lors de la
première utilisation est la suivante :
1. Créez un sous répertoire de travail pour stocker les fichiers relatifs à un problème que
vous souhaitez traiter avec R :
$ mkdir travail
$ cd travail
2. Démarrez R avec
$ R
3. Vous pouvez maintenant taper des commandes R.
4. Pour quitter, tapez
> q()
Il vous est alors demandé si vous souhaitez ou non sauver les données de la session.
Vous pouvez alors choisir de répondre yes, no ou cancel (la première lettre suffit) pour
sauver les données avant de quitter, quitter sans sauver ou revenir à la session R.
Les sessions qui suivent sont sur le même modèle :
1. Se placer dansle répertoire de travail et démarrer le programme comme précedemment
4
$ cd travail
$ R
2. Utiliser R en terminant par q() à la fin de la session.
Sous MS-Windows, la procèdure est grosso modo la même. Vous devez créer un répertoire
de travail et mettre son chemin dans le champ ‘start in’ (des propriètés) du raccourci.
Lancez alors R en double-cliquant sur l’icone.
1.6 Une session d’introduction
Si vous souhaitez tester un peu les possibilités de R avant de continuer, vous pouvez vous
reporter à la session d’introduction, voir Annexe A [Une session introductive], page 42.
1.7 Accèder à l’aide
R possède un système d’aide interne similaire au man d’UNIX. pour obtenir des informations sur une fonction, par exemple solve, la commande est :
> help(solve)
ou
> ?solve
Pour une fonctionnalité définie par des caractères spéciaux, l’argument doit être entouré
de guillemets, afin d’en faire une chaîne de caractères.
> help("[[")
Les deux formes de guillemets (simples et doubles) peuvent être utilisés ici; on préfèrera
les doubles, mais ce n’est qu’une convention.
Sur la plupart des versions, l’aide est disponible au format HTML et
> help.start()
lancera un butineur (netscape sous UNIX) qui permet de naviguer à travers les pages
d’aide grâce à des liens.
1.8 Les commandes de R; la casse etc.
Techniquement, R est un langage de commandes (interprèté) avec une syntaxe assez
simple. Il est sensible à la casse comme de nombreux programmes basés sur UNIX. Ainsi
A et a sont des symboles différents et ils identifient des variables différentes.
Les commandes de base consistent soit en expressions soit en affectations. Si une expression est tapée comme commande, elle est évaluée, affichée, et la valeur retournée est perdue.
Une affectation évalue également une expression mais passe sa valeur à une variable sans
automatiquement afficher le résultat.
Les commandes sont séparées soit par des points virgules (‘;’), soit par des sauts de ligne.
Les commentaires peuvent être mis a peu près n’importe où1 , en les précédant d’une dièse
(‘#’) : tout ce qui suivra jusqu’à la fin de la ligne sera un commentaire. Si une commande
n’est pas complète à la fin de la ligne, R affichera une invite différente, par défaut
1
pas dans des chaînes ni dans la définition de la liste des arguments d’une fonction
5
+
sur la seconde ligne et les suivantes. Il continuera à lire les entrées jusqu’à ce que la
commande soit syntaxiquement complète. Cette invite peut être modifiée par l’utilisateur.
On l’omettra généralement par la suite, signalant la continuation d’une commande par
l’indentation de ses lignes.
1.9 Rappel et correction de commandes
Sous la plupart des versions UNIX et MS-Windows, R fournit un mécanisme de rappel et
de re-exécution des commandes. Les flèches verticales du clavier permettent de parcourir un
historique des commandes. Quand une commande est ainsi rappellée, on peut y faire circuler
le curseur avec les flèches horizontales afin d’effacer (avec la touche hDELi) ou d’ajouter des
caractères. Plus de détails sont donnés par la suite, voir hundefinedi [L’editeur en ligne de
commande], page hundefinedi.
Les possibilités de rappel et d’édition sont hautement personnalisables sous UNIX. Pour
apprendre comment procèder, consultez la page man de la bibliothèque readline.
D’autre part, l’éditeur de texte emacs propose des possibilités très interressantes pour
travailler interactivement avec R (via “ESS”, Emacs Speaks Statistics). Voir section “R and
Emacs” dans The R statistical system FAQ.
1.10 Exécuter des commandes depuis un fichier; Rediriger
des sorties vers un fichier
On peut exécuter des commandes stockées dans un fichier ‘commands.R’ placé dans le
répertoire de travail ‘travail’ à tout moment pendant la session R :
> source("commandes.R")
Pour MS-Windows, source est disponible dans le menu File. La fonction sink,
> sink("sauve.lis")
enverra les sorties qui suivent non plus sur la console mais dans un fichier, ‘sauve.lis’. La
commande
> sink()
termine ce mode et permet que les sorties soient de nouveau envoyées vers la console.
1.11 Durée de vie des données; Effacer de objets
On appelle objets les entités créees et manipulées avec R. Ceux-ci peuvent être des
variables, des tableaux de nombres, des chaînes de caractères, des fonctions ou, plus
généralement des structures construites à partir de ces composants.
Pendant une session R, les objets sont crées et rangés par nom (on reparlera de ce
mécanisme dans le prochain chapitre). La commande
> objects()
(ou ls) sert à afficher les noms des objets stockés dans R sur le moment. La collection
d’objets stockés couramment est appelée espace de travail.
Pour effacer des objets on utilise la fonction rm :
6
> rm(x, y, z, ink, junk, temp, foo, bar)
Tous les objets crées pendant une session R peuvent être sauvés dans un fichier pour
une réutilisation dans une session ultérieure. A la fin de chaque session, R vous demande si
vous désirez sauver tous les objets courants. Si vous choisissez de le faire, les objets seront
écrits dans un fichier appelé ‘.RData’2 du répertoire courant.
Quand on démarrera R plus tard, il rechargera l’espace de travail contenu dans ce fichier
ainsi que l’historique des commandes correspondant.
Il est recommandé d’utiliser des répertoires différents pour les différentes analyses faites
avec R. Il est en effet assez fréquent que des objets nommés x ou y soient crées durant une
analyse. De tels noms peuvent avoir un sens pour un problème particulier, mais il peut
être difficile de s’y retrouver quand plusieurs problèmes sont menés à bien dans le même
répertoire.
2
le "point" rends le fichier invisible lors d’un listing normal sous UNIX
Chapitre 2: Manipulations de base; nombres et vecteurs
7
2 Manipulations de base; nombres et vecteurs
2.1 Vecteurs et affectation
R opère sur des structures de données. La structure de données la plus simple est
le vecteur numérique, qui est une entité constituée d’une collection ordonnée de chiffres.
Pour construire un vecteur x constitué des 5 chiffres 10.4, 5.6, 3.1, 6.4 et 21.7 on utilise la
commande :
> x <- c(10.4, 5.6, 3.1, 6.4, 21.7)
c’est une affectation utilisant ici la fonction c(). Dans ce contexte, la fonction c()
prends un nombre arbitraire d’arguments. Elle retourne un vecteur en concaténant ses
arguments1 (en les mettant bout à bout). Voir hundefinedi [...], page hundefinedi
Un chiffre apparaissant seul dans une expression est interprèté comme un vecteur de
longueur 1.
On note que l’opérateur d’affectation (‘<-’) n’est pas l’usuel opérateur ‘=’ qui est réservé
pour d’autres usages. Il est constitué de deux caractères, ‘<’ et ‘-’ placés strictement cote
à cote et qui ’pointent’ vers l’objet recevant la valeur de l’expression2 .
On peut également utiliser la fonction assign(). Avec celle-ci, une façon équivalente de
faire l’affectation précédente serait :
> assign("x", c(10.4, 5.6, 3.1, 6.4, 21.7))
L’opérateur usuel, <-, peut être vu comme un raccourci de cette opération.
Les affectations peuvent également être faites dans l’autre sens, en utilisant le changement trivial de l’opérateur. Cette même affectation peut donc s’écrire comme suit
> c(10.4, 5.6, 3.1, 6.4, 21.7) -> x
Si une expression est utilisée comme une commande complète, la valeur est imprimée à
l’écran et perdue 3 .
Si on utilisait la commande
> 1/x
les inverses des 5 valeurs seraient imprimées (et la valeur de x, bien sûr, resterait inchangée).
L’affectation suivante
> y <- c(x, 0, x)
crée un vecteur y avec 11 éléments : 2 copies de x avec un zéro au milieu.
1
2
3
Avec d’autres types d’arguments que des vecteurs, comme des arguments de mode liste, l’action de c()
est sensiblement différente...
Le caractère underscore ‘_’ est un synonyme de ‘<-’ mais il rend le code moins lisible.On décourage donc
son usage.
elle reste cependant disponible dans .Last.value avant qu’une autre action soit exécutée
8
2.2 Opérations sur les vecteurs
Les vecteurs peuvent être utilisés dans des expressions arithmétiques. Dans ce cas, les
opérations sont effectuées élément par élément.
Les vecteurs utilisés dans une même expression doivent tous être de même longueur. Si
ce n’est pas le cas, la valeur de l’expression est un vecteur de même longueur que le plus
grand vecteur utilisé dans l’expression.
Les vecteurs plus courts sont alors recyclés autant de fois que c’est nécessaire (avec une
éventuelle troncature) pour qu’ils aient la même taille que le plus grand. En particulier,
une constante est simplement répétée.
Avec la commande d’affectation suivante
> v <- 2*x + y + 1
On génère un nouveau vecteur v de longueur 11 construit en additionnant 2*x répèté
2,2 fois avec y répété 1 fois et 1 répété 11 fois.
Les opérateurs arithmètiques élémentaires sont +, -, *, / et ^ pour élever à une puissance.
De plus toutes les fonctions arithmétiques usuelles sont disponibles. log, exp, sin, cos, tan,
sqrt (racine carrée) etc. ont leur sens usuel. max et min renvoient respectivement le plus
grand et le plus petit élément d’un vecteur. range est une fonction retournant un vecteur
de longueur équivalent à c(min(x),max(x)). length(x) renvoies le nombre d’éléments de
x, sum(x) donnes la somme des éléments de x et prod(x) leur produit.
Deux fonction statisiques de base : mean(x) calcule la moyenne d’un échantillon, c’est
à dire la même chose que sum(x)/length(x), et var(x) calcule
sum((x-mean(x))^2)/(length(x)-1)
soit la variance de l’échantillon.
Si l’argument de var() est une matrice n-par-p, la valeur retournée est une matrice ppar-p de covariance obtenue en considèrant les lignes comme des p-variables indépendantes
(individus de l’échantillon).
sort(x) est une fonction de tri qui renvoies un vecteur de la même taille que x avec
ses éléments rangés par ordre croissant. Il existe d’autres fonctions adaptées à différentes
sortes de tris (voir order() et sort.list()).
max() (resp. min()) séléctionne le plus grand (resp. petit) élément de son ou ses
arguments (même si ce sont plusieurs vecteurs).
pmax() (resp. pmin()) est la fonction parallèle de maximum (resp. minimum).Elle
renvoie un vecteur de longueur égale à celle de son plus grand argument, qui contient le
plus grand (resp. petit) élément pour cette position parmi tous les vecteurs donnés en
argument.
La plupart du temps l’utilisateur n’aura pas à se soucier du fait que les nombres qui
composent un vecteur numérique sont des entiers, des réels ou même des complexes : les
calculs internes sont de toute façon faits en double précision.
Pour travailler avec des nombres complexes il suffit d’ajouter explicitement la partie
imaginaire. Ainsi
sqrt(-17)
donnera une erreur alors que
9
sqrt(-17+0i)
exécutera les calculs.
2.3 Générer des séquences de nombres
R permet de générer facilement les séquences de nombres les plus utiles. 1:30, par
exemple, correspond au vecteur c(1,2,3,...,29,30). L’opérateur : a la plus haute priorité
dans une expression. Ainsi 2*1:15 est le vecteur c(2,4,6,...,28,30). On peut s’amuser
pour s’en convaincre à comparer, avec n<-10, les suites 1:n-1 et 1:(n-1).
La construction 30:1 peut être utilisée pour générer une séquence en sens inverse.
On dispose également de la fonction seq() qui est une façon plus générale de produire
des séquences. Elle admet 5 arguments qui ne peuvent être utilisés tous en même temps.
Les 2 premiers arguments, s’ils sont spécifiés, donnent le début et la fin de la séquence. Si
ces 2 arguments sont les seuls à être donnés en entrée, le résultat est le même que pour
l’opérateur :. Ainsi seq(2,10) est équivalent à 2:10.
Les paramètres de seq, de même que ceux de nombreuses autres fonctions R, peuvent
être passés en argument avec leur nom. Dans ce cas, l’ordre dans lequel ils sont donnés n’a
pas d’importance. Les deux premiers arguments de seq() peuvent être passés sous la forme
from=valeur et to=valeur; Ainsi seq(1,30), seq(from=1,to=30) et seq(to=30,from=1)
sont tous équivalents à 1:30. Deux des autres arguments de seq sont by=valeur et
length=valeur. ils spécifient respectivement la taille du pas et la longueur de la séquence.
Si aucun des deux n’est donné, la valeur par défaut by=1 est utilisée.
Par exemple
> seq(-5, 5, by=.2) -> s3
affecte à s3 le vecteur c(-5.0,-4.8,-4.6,...,4.6,4.8,5.0).
De la même façon,
> s4 <- seq(length=51, from=-5, by=.2)
affecte le même vecteur à s4.
Le 5ème argument est along=vecteur, qui doit être utilisé seul. Il crée une séquence
1,2,...,length(vecteur) ou une suite vide si le vecteur est vide (il peut donc l’être...).
rep() est une fonction assez voisine de la précédente qui est utilisée pour répéter un objet.
La forme la plus simple de cette fonction (qui peut faire des choses plutôt complexes) est
> s5 <- rep(x, times=5)
cela mettra 5 copies de x bout à bout dans s5.
2.4 Vecteurs logiques
Comme pour les vecteurs numériques, R permet de faire des calculs avec des quantités logiques. Les éléments des vecteurs logiques peuvent prendre uniquement 2 valeurs,
représentées par FALSE et TRUE (abbréviés respectivement en F et T).
Les vecteurs logiques sont générés par des conditions. Par exemple
10
> temp <- x > 13
initialise temp à un vecteur de même longueur que x et dont les éléments ont la valeur FALSE
pour les éléments de x ne satisfaisant pas la condition, et TRUE pour les autres.
Les opérateurs logiques sont <, <=, >, >=, == pour l’égalité logique et != pour l’inégalité.
De plus, si c1 et c2 sont des expressions logiques, alors c1 & c2 est leur intersection (“et”),
c1 | c2 est leur union (“ou”) et !c1 est la négation de c1.
Les vecteurs logiques peuvent être utiliss comme des vecteurs arithmétiques pour des
calculs. Dans ce cas ils sont forcés en vecteurs numériques pour lesquels FALSE devient 0
et TRUE 1.
Il existe cependant des situations dans lesquelles les vecteurs logiques et leur pendant
numérique ne sont pas équivalents (voir le sous-chapitre suivant pour un exemple).
2.5 Valeurs manquantes
Dans certains cas, les composants d’un vecteur peuvent ne pas tous être connus. Quand
un élément ou une valeur n’est “pas disponible” ou “valeur manquante” au sens statistique
du terme, une place dans le vecteur peut lui être réservée en employant la valeur particulière
NA (Not Available). En général, toute opération sur un NA donne un NA. La raison pour
laquelle cette règle a été mise en place est que si l’on ne connait pas tous les éléments d’une
opération, le résultat ne peut pas être connu et donc n’est pas disponible.
La fonction is.na(x) donne un vecteur logique de la même taille que x avec la valeur
TRUE si et seulement si l’élément correspondant de x est un NA.
> z <- c(1:3,NA); ind <- is.na(z)
A noter que l’expression logique x==NA donne un résultat complètement différent de
is.na(x) puique NA n’est pas vraiment une valeur mais un identificateur pour une quantité
qui n’est pas disponible. x==NA est donc un vecteur de même longueur que x dont tous les
éléments sont des NA puique l’expression logique est incomplète.
Il y a une deuxième sorte de valeur “manquante” qui est produite par les calculs
numériques : la valeur appelée Not A Number, NaN. Par exemple
> 0/0
ou
> Inf - Inf
donnent toutes deux NaN car le résultat n’est pas défini.
Enfin, is.na(xx) renvoie TRUE pour les NA et les NaN tandis que is.nan(xx) donne TRUE
seulement pour les NaN.
2.6 Vecteurs de caractères
Les quantités caractères et les vecteurs de caractères sont fréquemment utilisés dans R,
par exemple pour les labels des graphes. ils sont représentés par une séquence de caractères
délimitée par un double guillemet : "x-max", "résultats de l’itération".
Les vecteurs de caractères peuvent être constitués avec la fonction c().
La fonction paste() prend un nombre quelconque d’arguments et les concatène en une
seule chaîne de caractères. Tous les nombres donnés parmi les arguments sont transformés
11
en chaînes de caractères. Par défaut, les arguments sont séparés par un caractère espace.
Ceci peut être changé en utilisant le paramètre sep=chaine, qui échange le caractère espace
pour chaine (qui peut être vide).
Par exemple
> labs <- paste(c("X","Y"), 1:10, sep="")
mets dans labs le vecteur de caractères
c("X1", "Y2", "X3", "Y4", "X5", "Y6", "X7", "Y8", "X9", "Y10")
On remarque que le recyclage a aussi cours ici; ainsi c("X", "Y") est répété 5 fois pour
correspondre à la séquence 1:10.4
2.7 Vecteurs indices; sélectionner et modifier des parties
d’un jeu de données
Une partie des éléments d’un vecteur peut être sélectionnée en ajoutant après le nom du
vecteur un vecteur indice entre crochets. Plus généralement, quand une expression retourne
un vecteur, on peut en selectionner une partie en ajoutant un vecteur indice immediatement
après l’expression.
Les vecteurs indice peuvent être de 4 types distinct :
1. Un vecteur logique. Dans ce cas le vecteur indice doit être de même longueur que
le vecteur selectionné. Les valeurs correspondant à TRUE dans le vecteur logique sont
selectionnées et les valeurs correspondant à FALSE sont omises.
Par exemple
> y <- x[!is.na(x)]
crée (ou recrée) un objet y qui contiendra les valeurs autres que manquantes, dans le
même ordre qu’elles apparaissent dans x. Si x a des valeurs manquantes, y sera plus
court que x. Ainsi
> (x+1)[(!is.na(x)) & x>0] -> z
crée un objet z et place dedans les valeurs de x+1 pour lesquelles les valeurs correspondantes de x sont non manquantes et positives.
2. Un vecteur d’entiers positifs. Dans ce cas les éléments de l’indice doivent appartenir à
l’ensemble {1, 2, . . . ,length(x)}. Les éléments correspondant du vecteur sont placés
suivant l’ordre donné par l’indice dans le vecteur résultat. Ce vecteur indice n’est
pas forcément de même longueur que le vecteur. Par exemple x[6] renvoie le sixième
composant de x et
> x[1:10]
sélectionne les 10 premiers éléments de x (si, bien sûr, length(x) est supérieur à 10).
De même
> c("x","y")[rep(c(1,2,2,1), times=4)]
produit un vecteur de caractères de longueur 16 constitué de "x", "y", "y", "x" répété
4 fois.
4
paste(..., collapse=ss) permet d’envoyer les arguments dans une chaîne de caractères en mettant ss
entre eux. Il y a beaucoup d’autres outils pour la manipulation des caractères. Voir l’aide pour sub et
substring.
12
3. Un vecteur d’entiers négatifs. Un vecteur d’indice de cette forme sert à spécifier les
valeurs à écarter plutôt que celles à sélectionner. Ainsi
> y <- x[-(1:5)]
mets dans y tous les éléments de x sauf les 5 premiers.
4. Un vecteur de caractères. Cette possibilité s’applique seulement dans le cas ou l’objet a
un attribut names pour identifier ses éléments. Dans ce cas un sous-vecteur du vecteur
des noms permet de sélectionner des éléments de x de la même façon que les vecteurs
d’entiers du cas 2.
> fruit <- c(5, 10, 1, 20)
> names(fruit) <- c("orange", "banana", "apple", "peach")
> lunch <- fruit[c("apple","orange")]
L’avantage des caractères (et de l’attribut names) sur les chiffres c’est qu’on s’en souvient plus facilement. Cette dernière solution est particulièrement utile quand on manipule des data frames comme nous le verrons plus tard.
Une expression indicée peut aussi apparaître du côté réception de la flèche. Dans ce cas
l’affectation se fait seulement pour ces éléments (sélectionnés) du vecteur. L’expression doit
être de la forme vecteur[vecteur indice] puisqu’avoir une expression à la place du nom du
vecteur n’aurait pas ici beaucoup de sens. Le vecteur affecté doit évidemment être de même
longueur que le vecteur indice.
> x[is.na(x)] <- 0
remplace toute valeur manquante de x par zéro et
> y[y < 0] <- -y[y < 0]
a le même effet que
> y <- abs(y)
2.8 Autres types d’objets
Les vecteur représentent le type d’objet le plus important de R mais il en est d’autres
que nous rencontrerons plus précisément dans les chapitres suivants
• Les matrices ou plus généralement les tableaux sont des généralisations multidimensionnelles des vecteurs. En fait ce sont des vecteurs qui peuvent être indicés par 2
(ou plus) indices et qui seront affichés à l’écran de façon spéciale. Voir hundefinedi
[Tableaux et matrices], page hundefinedi.
• Les facteurs permettent de manipuler les données qualitatives. Voir hundefinedi [Facteurs], page hundefinedi.
• Les listes sont une forme plus générale de vecteurs dans laquelle les éléments n’ont pas
besoin d’être tous du même type. Ces éléments sont souvent eux-même des vecteurs ou
des listes. Les listes fournissent un bon moyen pour renvoyer les résultats de fonctions
statistiques. Voir hundefinedi [Listes et data frames], page hundefinedi.
• Les data frames sont des structures semblables aux matrices, dans lesquelles les colonnes
peuvent être de types différents. Pensez aux data frames comme à des ’matrices de
données’ avec une ligne par observation et avec (si nécessaire) des variables numériques
et catégorielles. Les data frame sont adaptés pour traiter un grand nombre de données
13
expérimentales : les traitements sont catégoriels mais la réponse est numérique. Voir
hundefinedi [Listes et data frames], page hundefinedi.
• les fonctions sont aussi des objets en R et elles peuvent être stockées dans l’espace
de travail d’un projet. Ceci fournit un moyen pratique et simple d’étendre R. Voir
hundefinedi [Ecrire vos propres fonctions], page hundefinedi.
Chapitre 3: Objets; leurs modes et attributs
14
3 Objets; leurs modes et attributs
3.1 Attributs intrinsèques : mode et longueur
Les eléments sur lesquels agit R sont techniquement nommés objets. Les vecteurs de
réels ou de nombres complexes, les vecteurs de valeurs logiques ou de chaînes de caractères
en sont des exemples. Tous ces éléments sont des structures dites "atomiques" car leur
composants sont tous de même type ou mode, respectivement numeric 1 , complex, logical et
character.
Les éléments d’un vecteur doivent tous être du même mode. Ainsi tout vecteur doit sans
ambiguité être numeric, complex,logical ou character. La seule exception à cette règle est
pour les valeurs spéciales NA représentant des valeurs manquantes.
On notera qu’un vecteur vide peut aussi avoir un mode,. Par exemple, le vecteur de
chaîne de caractère vide est listé character(0) tandis que le vecteur numérique vide donne
numeric(0).
R agit aussi sur des objets appellés listes, qui sont de mode list. Ce sont des séquences ordonnées d’objets qui peuvent être de n’importe quel mode. Les listes sont dites "récursives",
plutôt qu’atomiques, car leurs composants peuvent eux-même être des listes.
Les structures de mode function et expression sont également récursives. Les fonctions
sont des objets qui forment la base de R, avec les fonctions utilisateur sur lesquelles nous
reviendrons plus en détail par la suite. Les expressions, en tant qu’objets, ont un rôle assez
complexe en R. Elles ne seront pas documentées dans ce guide, si ce n’est indirectement
dans la description des formules utilisées pour la modèlisation.
On nomme mode d’un objet le type de base de ses éléments fondamentaux. C’est l’une
des "propriètés" d’un objet. La longueur est une autre des propriètés que possède tout
objet. Les fonctions mode(objet) et length(objet) permettent d’accèder au mode et à la
longueur de toute structure.
D’autres propriètés d’un objet peuvent être extraites par attributes(object), voir Section 3.3 [Obtenir et modifier des attributs], page 15. Les mode et longueur sont appellés
"attributs intrinsèques" d’un objets car ils sont communs à tous les objets.
Par exemple, si z est un vecteur de complexes de longueur 100, alors, dans une expression,
mode(z) est la chaîne de caractères "complex" et length(z) est l’entier 100.
R s’occupe des changements de mode partout où il est sensé le faire. Par exemple avec
> z <- 0:9
On peut faire
> nombres <- as.character(z)
après quoi nombres sera le vecteur de caractères c("0", "1", "2",..., "9"). Un forçage
de plus, ou changement de mode, reconstruit le vecteur numérique :
> d <- as.integer(digits)
1
Le mode numeric est un amalgame de deux modes distincts, integer et double précision.
15
maintenant d et z sont les mêmes.2 . Il y a une grande diversité de fonctions de la forme
as.qqchose() soit pour le forçage d’un mode à l’autre, soit pour rajouter un attribut à
un objet. Le lecteur consultera les différents fichiers d’aide pour se familiariser avec ces
fonctions.
3.2 Changer la longueur d’un objet
Un objet peut être vide et avoir un mode. Par exemple
> e <- numeric()
fait de e une structure vectorielle de mode numérique. De la même faon, character()
est un vecteur -vide- de caractères et ainsi de suite. Une fois qu’un objet, quelle que soit sa
taille, a été crée, de nouveaux composants peuvent lui être ajoutés en l’indiçant avec une
valeur plus grande que son rang. Ainsi
> e[3] <- 17
fait de e un vecteur de longueur 3 (dont les deux premiers sont pour l’instant des NA).
Ceci s’applique à toute structure, en admettant que le mode des nouveaux arguments est
compatible avec celui des premiers objets de la structure.
Cet ajustement automatique de la longueur des objets est souvent utilisé, par exemple
pour les entrées de la fonction scan(). (Voir Section 6.2 [La fonction scan()], page 24.)
De même, tronquer la taille d’un objet ne necessite qu’une affectation. Ainsi si alpha
est un objet de longueur 10, alors
> alpha <- alpha[2 * 1:5]
en fait un objet de longueur 5 avec les composants sélectionnés, indices compris. Les anciens
indices ne sont bien sûr pas retenus.
3.3 Obtenir et modifier des attributs
La fonction attributes(objet) donne une liste de tous les attributs non-intrinsèques
définis pour cet objet. La fonction attr(objet, nom) peut être utilisée pour sélectionner un
attribut spécifique. Ces fonctions sont rarement utilisées, sauf dans des cas assez particuliers,
quand on crée un nouvel attribut dans un but précis (par exemple pour associer une date
de création ou un opérateur à un objet R). Le concept, cependant, est très important.
On devra donc faire attention, quand on ajoute ou supprime des attributs, car ils sont
partie intègrante du système d’objets utilisé en R.
utiliser la fonction attr du coté gauche d’une affectation sert soit à associer un nouvel
attribut à un objet, soit à en modifier un déjà existant. Par exemple
> attr(z,"dim") <- c(10,10)
permet de traiter z comme une matrice 10x10.
2
En général, le forçage de numeric à character ne sera pas tout à fait équivalent à cause des erreurs
d’arrondis dans la représentation des caractères
16
3.4 La classe d’un objet
Un attribut spécial, appellé classe d’un objet, est utilisé pour un style de programmation
R orientée objet.
Par exemple si un objet est de classe "data.frame", il sera affiché d’une certaine
façon, la fonction plot fera un graphique adaptée, et d’autres fonctions génériques, comme
summary(), le traiteront de la façon appropriée à sa classe.
Pour supprimer temporairement les effets dus à une classe, on utilise la fonction
unclass(). Par exemple si winter est de classe "data.frame" alors
> winter
l’affichera comme un data frame, ce qui ressemble à la façon dont sont affichées les matrices,
tandis que
> unclass(winter)
l’affichera comme une liste ordinaire. Ce n’est que dans des situations particulières que
l’on a besoin de cette fonctionnalité, et seulement quand on en vient à utiliser les fonctions
génériques
Ces dernières seront brièvement développées dans hundefinedi [Oriente objet], page hundefinedi.
Chapitre 4: Facteurs ordonnés et non-ordonnés
17
4 Facteurs ordonnés et non-ordonnés
Un facteur est un objet vectoriel utilisé pour identifier les composants d’autres vecteurs
de même longueur de faon discrète. R fournit des facteurs ordonnés et non-ordonnés. La
réelle application des facteurs est dans les formules décrivant des modèles (voir hundefinedi
[Contrasts], page hundefinedi, nous allons cependant regarder ici un
4.1 Exemple spécifique
Supposons par exemple que nous ayons un échantillon de 30 contribuables de tous les
territoires australiens1 et que leur territoire d’origine est donné par un vecteur de caractères
> etat <- c("tas", "sa", "qld", "nsw", "nsw", "nt", "wa", "wa",
"qld", "vic", "nsw", "vic", "qld", "qld", "sa", "tas",
"sa", "nt", "wa", "vic", "qld", "nsw", "nsw", "wa",
"sa", "act", "nsw", "vic", "vic", "act")
Remarque : dans le cas d’un vecteur de caractères, "trié" signifie "trié par ordre alphabètique".
Un facteur est crée grce à la fonction factor :
> etatf <- factor(state)
La fonction print traite les facteurs de faon spéciale :
> etatf
[1] tas sa qld nsw nsw nt wa wa qld vic nsw vic qld qld sa
[16] tas sa nt wa vic qld nsw nsw wa sa act nsw vic vic act
Levels: act nsw nt qld sa tas vic wa
On utilise la fonction levels() pour connaître les niveaux du facteur.
> levels(etatf)
[1] "act" "nsw" "nt" "qld" "sa" "tas" "vic" "wa"
4.2 La fonction tapply et les tableaux irréguliers
Pour continuer l’exemple précédent, supposons que nous ayons les revenus des mêmes
contribuables stockés dans un vecteur (en milliers d’euros par exemple).
> revenus <- c(60, 49, 40, 61, 64, 60, 59, 54, 62, 69, 70, 42, 56,
61, 61, 61, 58, 51, 48, 65, 49, 49, 41, 48, 52, 46,
59, 46, 58, 43)
Pour calculer la moyenne empirique des revenus dans chaque état, on peut ici utiliser la
fonction tapply() :
> moy.rev <- tapply(revenus,etatf,mean)
ce qui donne un vecteur contenant les moyennes identifiées par les niveaux
act
nsw
nt
qld
sa
tas
vic
wa
44.500 57.333 55.500 53.600 55.000 60.500 56.000 52.250
1
il y a 8 états et territoires en australie : Australian Capital Territory, New South Wales, the Northern
Territory, Queensland, South Australia, Tasmania, Victoria and Western Australia.
Chapitre 4: Facteurs ordonnés et non-ordonnés
18
La fonction tapply est utilisée pour appliquer une fonction, ici mean(), à chaque groupe
d’éléments du premier argument (ici revenus), définis par les niveaux du deux‘@‘eme argument (ici etatf) comme s’ils étaient des structures vectorielles séparées. Le résultat est
une structure de même longueur que l’attribut levels du facteur identifiant les groupes.
Le lecteur consultera l’aide associée @‘a tapply pour plus de détails.
Supposons qu’on veuille calculer les écarts-types des revenus par état. Pour ce faire, on
a besoin d’écrire une fonction R] qui calcule l’écart-type d’un vecteur quelconque. Comme
on dispose de la fonction var() qui calcule la variance empirique, elle va être facile à écrire
:
ec.type <- function(x) sqrt(var(x)/length(x))
(On reviendra plus loin sur l’écriture des fonction, hundefinedi [ecrire ses propres fonctions],
page hundefinedi) Après cette allocation, les écarts-types sont calculés par
> rev.ectype <- tapply(revenus, etatf, ec.type)
et les valeurs calculées sont alors
> rev.ectype
act
nsw nt
qld
sa tas
vic
wa
1.5 4.3102 4.5 4.1061 2.7386 0.5 5.244 2.6575
La fonction tapply() peut selectionner les éléments d’un vecteur de faon moins triviale,
entre autre sur des critères multiples. Par exemple, on peut vouloir séparer les contribuables
sur l’état et le sexe en même temps. Dans ce cas (une seule catégorie) la fonction voulue
est appliquée sur chacun des groupes correspondant aux différentes entrées de la catégorie;
le résultat retourné est un vecteur ayant pour longueur le nombre de catégories et dont les
éléments sont identifiés par l’attribut levels du facteur catégorie.
La combinaison d’un vecteur et d’un facteur de labels est un exemple de ce que l’on
nomme tableau irrégulier du fait que les tailles des classes définies par les labels peuvent
être différentes.
Quand les tailles de ces classes sont toutes les même, la sélection des éléments peut se
faire de faon plus simple et plus efficace, comme nous le verrons dans le chapitre suivant.
4.3 Facteurs ordonnés
Les niveaux de facteur sont rangés soit par ordre alphabètique, soit dans l’ordre dans
lequel ils ont été spécifiés à factor() s’ils ont été spécifiés explicitement.
Dans certains cas, les niveaux auront un ordre naturel que l’on souhaite conserver et
dont notre analyse doit tenir compte. La fonction ordered crée des facteurs ayant cette
fonctionnalité, étant d’autre part identique à factor().En général, la seule différence entre
facteurs ordonnés et non-ordonnés est que les premiers sont affichés de faon à montrer l’ordre
des niveaux; de plus les contrastes définis à partir de ceux-ci pour ajuster des modèles
linéaires sont différents.
Chapitre 5: Listes et data frames
19
5 Listes et data frames
5.1 Listes
Une liste R est un objet qui contient une collection ordonnée d’objets appellés ses composants.
Il n’est pas nécessaire que les composants soient du même type ou du même mode, et,
par exemple, une liste peut être composée d’un vecteur numérique, d’une valeur logique,
d’une matrice, d’un vecteur de complexes, d’un tableau de caractères, d’une fonction etc.
Voici un exemple de la manière de créer une liste :
> Lst <- list(nom="Fred", femme="Stella", nb.enfants=3,
ages.enfants=c(4,7,9))
Les composants sont toujours numérotés et peuvent donc être identifiés par leur numéro.
Ainsi, si Lst est le nom d’une liste de 4 composants, on peut accèder à ceux-ci par Lst[[1]],
Lst[[2]], Lst[[3]] et Lst[[4]]. Si, de plus, Lst[[4]] est un vecteur alors Lst[[4]][1]
est sa première valeur.
Si Lst est une liste, alors la fonction length(Lst) donne le nombre de ses composants
(de premier niveau).
Les composants d’une liste peuvent aussi être nommés, et dans ce cas on peut y accèder
soit en remplaçant le nombre entre crochets par le nom (sous forme de chaîne de caractères),
soit, de façon plus conventionnelle, en donnant une expression de la forme
> name$nom composant
Cette convention est très utile car on peut accèder au composant même si on a oublié
son numéro.
Dans l’exemple basique ci-dessus :
Lst$nom identifie la même chose que Lst[[1]] c’est à dire la chaîne "Fred",
Lst$femme identifie la même chose que Lst[[2]] c’est à dire la chaîne "Stella",
Lst$child.ages[1] identifie la même chose que Lst[[4]][1] c’est à dire le nombre 4.
De plus on peut utiliser les noms des composants entre double crochets, i.e.,
Lst[["nom"]] ce qui est la même chose que Lst$nom. Ceci est particulièrement utile
quand le nom du composant à extraire est stocké dans une variable; comme
> x <- "name"; Lst[[x]]
Il est très important de distinguer Lst[[1]] de Lst[1]. ‘[[. . . ]]’ est un opérateur
utilisé pour sélectionner un seul élément, tandis que ‘[. . . ]’ est un opérateur plus général
d’indiçage. Ainsi la première forme donne le premier objet de la liste Lst, et, si c’est une
liste nommée, le nom de l’objet n’est pas inclus. La deuxième forme extrait une sous-liste
de la liste Lst constituée de la première entrée seulement. Si c’est une liste nommée, les
noms sont inclus dans la sous-liste.
Les noms des composants peuvent être raccourcis au plus petit nombre de lettres
nécessaire pour les distinguer de manière unique. Ainsi Lst$coefficients peut être
spécifié au minimum par Lst$coe et Lst$covariance par Lst$cov. Le vecteur des noms
est en fait un simple attribut de la liste et peut donc être utilisé comme tel. D’autres
structures que les listes peuvent aussi avoir un attribut names.
20
5.2 Construire et modifier des listes
Les listes peuvent être construites à partir d’objets existants avec la fonction list().
Une affectation de la forme
> Lst <- list(nom 1=objet 1, . . . , nom m=objet m)
initialise une liste Lst de m composants avec objet 1, . . . , objet m pour composants dont
les noms sont respectivement nom 1,. . . , nom m. Si ces nom étaient omis, les composants
seraient repérés seulement par leurs numéros correspondant. Les composants utilisés sont
copiés pour former la liste, et les originaux restent inchangés.
Les listes, comme tous les objets indiçables, peuvent être étendues en leur ajoutant des
composants. Par exemple
> Lst[5] <- list(matrix=Mat)
5.2.1 Concatèner des listes
Quand les arguments de la fonction de concaténation c() sont des listes, le résultat est
aussi un objet de mode liste, dont les composants sont ceux des listes ajoutés bout à bout
> list.ABC <- c(list.A, list.B, list.C)
Rappellez-vous qu’avec des vecteurs en argument, la fonction de concaténation met de
façon similaire tous les arguments dans une seule structure vectorielle. Dans ce cas, les
autres attributs, comme les attributs dim, sont perdus.
5.3 Data frames
Un "data.frame" est une liste de classe "data.frame", mais il y a des restrictions sur
les listes pour devenir des data frames :
• Les composants doivent être des vecteurs (numériques, de caractères ou logiques), des
facteurs, des matrices numériques, des listes ou d’autres data frames.
• Les matrices, listes ou data frames fournissent autant de variables au nouveau data
frame qu’elles ont de colonnes, d’éléments ou de variables respectivement.
• Les vecteurs numériques et les facteurs sont inclus tels quels mais les vecteurs nonnumériques (caractères et logiques) sont forcés en facteurs dont les niveaux sont les
valeurs (uniques) apparaissant dans le vecteur.
• Les structures vectorielles variables du data frame doivent avoir la même longueur, et
les structures matricielles doivent avoir le même nombre de lignes.
Un data frame peut, dans de nombreux cas, être vu comme une matrice avec des colonnes
ayant des modes et attributs différents. Il peut être affiché comme une matrice et ses lignes
et colonnes extraites en utilisant les conventions d’indiçage des matrices.
5.3.1 Construire des data frames
Les objets satisfaisant les conditions sur les colonnes (composants) d’un data frame
peuvent être utilisés pour en construire un à l’aide de la fonction data.frame:
21
> accountants <- data.frame(home=statef, loot=income, shot=incomef)
Une liste dont les composants se conforment aux restrictions imposées aux data frame
peut être forcée en data frame en utilisant la fonction as.data.frame()
La façon la plus simple de construire un data frame à partir de rien est d’utiliser la
fonction read.table pour lire un data frame stocké dans un fichier. Ceci est expliqué plus
en détails dans la section Chapitre 6 [Lire des donnees dans des fichiers], page 23.
5.3.2 attach() et detach()
La notation $, comme dans accountants$statef, n’est pas toujours très pratique pour
accèder aux composants des listes. Il serait utile de les rendre temporairement visibles
comme si c’étaient des variables (sans avoir besoin d’y adjoindre constamment le nom de la
liste).
La fonction attach(), de même qu’elle peut avoir un nom de répertoire en argument,
peut aussi avoir un data frame. En supposant que Lentilles est un data frame avec 3
variables Lentilles$u, Lentilles$v, Lentilles$w l’attacher
> attach(Lentilles)
place le data frame en position 2 du path. S’il n’y a pas de variables u, v ou w en position 1,
u, v et w sont maintenat manipulables en tant que variables du data frame mais sous leurs
propres noms.
Ici une affectation comme
> u <- v+w
ne modifiera pas le composant u du data frame mais le masquera par une nouvelle valeur
u en position 1 du search path du répertoire de travail. Pour faire un changement dans le
data frame, la façon la plus simple est de se resservir de la notation $ :
> Lentilles$u <- v+w
Cependant la nouvelle valeur du composant u ne sera pas visible avant que le data frame
ne soit détaché.
Pour détacher un data frame on utilise la fonction
> detach()
Ceci, plus précisément, détache du search path ce qui se trouve en position 2. Ainsi,
dans ce contexte, les variables u, v et w ne seront plus visibles, excepté avec la notation de
liste $. Les entités aux positions supérieures à 2 dans le search path peuvent être détachées
en donnant leur numéro en argument de detach, mais il est toujours plus prudent d’utiliser
leur nom, par exemple par detach(Lentilles) ou detach("Lentilles")
NOTE: Dans la version actuelle de R, le search path ne peut contenir plus de
20 éléments. Evitez d’attacher le même data frame plus d’une fois. Détachez
toujours un data frame aussit que vous en avez fini avec ses variables.
NOTE: Dans la version actuelle, les data frames ne peuvent être attachés qu’en
position 2 ou après.
22
5.3.3 Travailler avec les data frames
Voici quelques règles qui vous permettront de travailler de front sur de nombreux
problèmes dans le même répertoire :
• rassemblez, pour chaque analyse, toutes les variables dans un data frame au nom explicite;
• quand vous travaillez sur une analyse, attachez le data frame correspondant en
position 2 et utilisez le répertoire de travail au niveau 1 pour stocker les variables
intermédiaires et temporaires;
• avant d’en terminer avec votre analyse, rajoutez toutes les variables de quelque interêt
à votre data frame en utilisant le $ et ensuite faites detach();
• finalement, effacez du répertoire de travail les variables indésirables et essayer de le
garder vierge de toute variable temporaire dans la mesure du possible.
De cette façon il est facile de travailler sur de nombreux problèmes dans le même
répertoire, même si on a dans plusieurs de ceux-ci des variables x, y et z par exemple.
5.3.4 Attacher des listes
attach() est une fonction générique qui permet d’attacher non seulement des répertoires
et des data frames au search path, mais aussi d’autres classes d’objets. En particulier, tout
objet de mode list peut être attaché :
> attach(une.vieille.liste)
Tout ce qui a été attaché peut ensuite être détaché par detach, avec le numéro de
position, ou, de préférence, avec le nom en argument.
5.3.5 Gérer le search path
La fonction search affiche le search path courant et est donc très utile pour garder la
trace des data frames et des listes (et aussi des packages) qui ont été attachés et détachés.
Au départ cela donne :
> search()
[1] ".GlobalEnv"
"Autoloads"
"package:base"
1
oú .GlobalEnv est le workspace.
Après que Lentilles ait été attaché on a
> search()
[1] ".GlobalEnv"
"Lentilles"
"Autoloads"
"package:base"
> ls(2)
[1] "u" "v" "w"
comme nous avons vu ls (ou objects) peut être utilisé pour examiner le contenu de chaque
position du search path.
Finalement, on détache le data frame et on vérifie qu’il a bien été détaché.
> detach("lentils")
> search()
[1] ".GlobalEnv"
"Autoloads"
"package:base"
1
Voir l’aide en ligne pour autoload pour la signification du deuxième terme.
Chapitre 6: Lire des données dans des fichiers
23
6 Lire des données dans des fichiers
Les gros jeux de données seront en général lus dans des fichiers externes plutôt qu’entrés
à la main durant une session R. Le mécanisme de lecture de R est assez simple mais il a des
exigences très strictes. Les constructeurs de R ont clairement présumé que l’on serait à même
de modifier les fichiers avec d’autres outils , comme des éditeurs de texte (emacs ou autre)
ou perl1 pour satisfaire aux exigences de R. En général c’est très simple. Il y a cependant
une fonction read.fwf() qui peut être utilisée pour lire des fichiers dans lesquels les champs
sont de longueur fixée et non-séparés.(ceci est réalisé par un script perl qui qui convertit
le fichier dans un format utilisable et le passe à read.table). Il y a aussi count.fields()
qui permet de compter le nombre de champs sur chaque ligne d’un tel fichier. En certaines
occasions, pour de très simples problèmes de conversion ou de vérification, elles pourront
faire l’affaire. Cependant il est préférable de faire le travail de débroussaillage des données
avant de débuter la session R. Pour lire un jeu de données entier, on utilisera la fonction
read.table().La fonction scan(), plus primitive, peut aussi être utilisée.
6.1 La fonction read.table()
Pour lire un jeu de données de faon directe, le fichier qui le contient devra normalement
avoir une forme bien définie :
• La première ligne du fichier devra comporter le nom de chaque variable-colonne du jeu
de données.
• Toutes les lignes du fichier qui suivent doivent avoir comme premier élément un indice
de ligne puis les valeurs pour chaque variable.
Si le fichier a un élément de moins dans sa première ligne que dans la seconde, c’est cette
convention qui sera utilisée. Les premières lignes d’un tel fichier de données ressembleront
à ce qui suit :
Forme du fichier avec indices de ligne:
01
02
03
04
05
...
Prix
52.00
54.75
57.50
57.50
59.75
Surface
111.0
128.0
101.0
131.0
93.0
Terrain Pièces
830
5
710
5
1000
5
690
6
900
5
Age
6.2
7.5
4.2
8.8
1.9
Chauff.central
non
non
non
non
oui
Par défaut les éléments numériques (à l’exception des indices de ligne) sont lus comme des
variables numériques et les éléments non-numériques, comme Chauff.central dans notre exemple, comme des facteurs. Ceci peut être modifié si nécessaire. La fonction read.table()
peut être utilisée directement pour lire ce jeu de données.
> PrixMaison <- read.table("maison.data")
1
comme sed ou awk sous UNIX
24
Souvent vous ne voudrez pas mettre les indices de lignes et utiliser les indices par défaut.
Dans ce cas, il suffit que le fichier ne contienne pas la colonne d’indices, comme dans ce qui
suit.
Fichier sans indices de ligne:
Prix
52.00
54.75
57.50
57.50
59.75
...
Surface
111.0
128.0
101.0
131.0
93.0
Terrain Pièces
830
5
710
5
1000
5
690
6
900
5
Age
6.2
7.5
4.2
8.8
1.9
Chauff.central
non
non
non
non
oui
Ce fichier de données peut être lu par
> PrixMaison <- read.table("maison.data", header=TRUE)
Où l’option header=TRUE spécifies que la première ligne est la ligne des en-têtes, et, vu
la forme des données, qu’aucun nom de ligne explicite n’est fourni.
6.2 La fonction scan()
Supposons que l’on a des vecteurs de données que l’on veut lire en parallèle. Supposons
de plus qu’il y a trois vecteurs, le premier de mode caractère et les deux autres de mode
numérique, dans le fichier ‘entree.dat’. La première étape consiste dans ce cas à utiliser
scan() pour lire les 3 vecteurs comme une liste, de la faon suivante :
> in <- scan("entree.dat", list("",0,0))
Le deuxième argument est une liste factice qui donne le mode des vecteurs à lire. Le
résultat stocké dans in, est une liste dont les composants sont les trois vecteurs lus. Pour
séparer les éléments de la liste en trois vecteurs, on utilise une allocation du type
> label <- in[[1]]; x <- in[[2]]; y <- in[[3]]
Plus commodément, la liste factice peut avoir des arguments nommés;Dans ce cas ces
noms peuvent être utilisés pour accèder aux vecteurs. Par exemple :
> in <- scan("entree.dat", list(id="", x=0, y=0))
Si vous voulez accèder aux variables séparément, vous pouvez soit les reallouer dans
l’environnement de travail :
> label <- in$id; x <- in$x; y <- in$y
Soit les utiliser en attachant la liste en position 2 du chemin de recherche (voir hundefinedi [Attacher des listes], page hundefinedi). Si le deuxième argument est une valeur
simple au lieu d’une liste, une vecteur unique est lu dont tous les éléments doivent être du
même mode que la valeur factice.
> X <- matrix(scan("light.dat", 0), ncol=5, byrow=TRUE)
25
6.3 Accèder aux jeux de données de base
Plus de cinquante jeux de données sont fournis avec R , et d’autres sont disponibles dans
les packages (y compris les packages standard fournis avec R). Contrairement à S-Plus, ces
jeux de données doivent être chargés de faon explicite en utilisant la fonction data. Pour
avoir la liste des jeux de données du système de base, on utilise
data()
et pour en charger un, par exemple,
data(infert)
Dans la plupart des cas, ceci chargera un objet R du même nom , en général un data frame.
Cependant, dans quelques cas, ceci chargera plusieurs objets, regardez l’aide en ligne sur
les données à charger pour savoir à quoi s’attendre.
6.3.1 charger des données d’autres packages
Pour accèder aux donnée d’autres packages, utilisez l’argument package, par exemple
data(package="nls")
data(Puromycin, package="nls")
Si un package a été attaché par library, ses jeux de données sont automatiquement
inclus dans la recherche, de telle sorte que
library(nls)
data()
data(Puromycin)
fera la liste de tous les jeux de données dans les packages attachés (au moins base et nls
ici) et chargera ensuite Puromycin depuis le premier package dans lequel ce jeu de données
est trouvé. Les packages écrits par des utilisateurs peuvent être une source riche de jeux
de donnée : par exemple, avec les notes du Dr Venables, source de ce document, vient un
ensemble de données qui est maintenant disponible sur le CRAN sous le nom de package
Rnotes.
6.4 Editer des données
Une fois qu’un jeu de données a été lu, il existe une fonctionnalité dans certaines versions
de R qui permet de faire de petits changements dans une fenêtre spéciale. La commande
> xnouveau <- data.entry(xvieux)
vous permet d’éditer votre vieux jeu de données xvieux en utilisant uin environnement du
style feuille de calcul. Après changements, le jeu de données est envoyé dans xnouveau.
xvieux, et donc xnouveau, peuvent être matrice, vecteur, data frame ou objet atomique.
Appeler data.entry() sans arguments
> xnouveau <- data.entry()
vous permet d’entrer de nouvelles données via cet interface.
26
6.5 Importer des données
Il peut être important dans certains projets d’importer des données de bases de données
externes ou de fichiers conus pour d’autres systèmes. Il y a plusieurs packages développés
dans le but de rendre l’importation des données en R plus facile. Actuellement il existe
un package stataread qui permet de lire et écrire des fichiers stata ainsi qu’un package
expérimental, foreign, qui sera capable de lire des fichiers SAS, Minitab et SPSS. Plusieurs
packages proposent une interface pour les bases de données SQL et un package RODBC
est développé pour fournir une connexion aux bases de données ODBC (comme access sous
MS-Windows).
Chapitre 7: Complément sur le langage. Boucles et exécution conditionnelle.
27
7 Complément sur le langage. Boucles et
exécution conditionnelle.
7.1 Expressions groupées
R est un langage d’expressions dans le sens ou son seul type de commandes est une
fonction ou une expression qui retourne une valeur résultat. Même une allocation est une
expression, dont le résultat est une valeur allouée - et à ce titre elle peut être utilisée partout
o une expression peut l’être. En particulier, les allocations multiples sont possibles.
Les commandes peuvent être groupées ensemble dans des accolades, {expr 1; . . . ;
expr m}. Dans ce cas, la valeur du groupe est le résultatde la dernière expression. Puisqu’un
tel groupe est aussi une expression, il peut aussi, par exemple, être lui-même inclus dans
des parenthèses et utilisé dans une expression plus grande, et ainsi de suite.
7.2 Les instructions de contrôle
7.2.1 Exécution conditionnelle : l’instruction if.
Le langage possède une instruction conditionnelle de la forme
> if (expr 1) expr 2 else expr 3
o expr 1 doit retourner une valeur logique. Le résultat de l’expression complète est
évident.
Les opérateur && et || sont souvent utilisés dans la condition d’une instruction if. Alors
que & et | s’appliquent aux éléments d’un vecteur, && et || s’appliquent à des vecteurs de
longueur 1 et évaluent seulement le second élément si nécessaire.
Il y a également une version vectorielle du if/else : la fonction ifelse. Elle a la forme
ifelse(condition, a,b) et retourne un vecteur de même longueur que son plus grand
argument, avec les éléments a[i] si condition[i] est vraie et b[i] sinon.
7.2.2 éxecution repetitive : les boucles for, repeat et while.
Il existe également une boucle for qui a la forme
> for (nom in expr 1) expr 2
où nom est la variable de boucle . expr 1 est une expression vectorielle , (souvent une
séquence comme 1:20), et expr 2 est souvent un groupe d’expression qui composent avec
le nom. expr 2 est évalué de faon répétitive tant que nom parcourt les valeurs du vecteur
résultat de expr 1.
Regardons un exemple o l’on suppose que ind est un vecteur de catégories; On veut
faire un graphique de y contre x pour chaque catégorie. une possibilité serait ici d’utiliser
coplot(), que nous verrons plus tard, qui dessine une matrice de graphes correspondant à
chaque catégorie. Une autre faon de faire cela, en mettant dessinant toutes les courbes sur
le même graphes est la suivante :
> xc <- split(x, ind)
> yc <- split(y, ind)
> for (i in 1:length(yc)) {
Chapitre 7: Complément sur le langage. Boucles et exécution conditionnelle.
28
plot(xc[[i]], yc[[i]]);
abline(lsfit(xc[[i]], yc[[i]]))
}
(Remarquez l’utilisation de la fonction split() qui produit une liste de vecteurs obtenus
en séparant un vecteur d’après les classes d’un vecteur catégoriel. C’est une fonction très
utile, surtout utilisée en connection avec les boxplot. regardez sa page d’aide pour de plus
amples détails.)
ATTENTION : les boucles for sont beaucoup moins utilisées dans le code R
que dans des langages compilés. Un code qui compose avec des objets entiers
est plus clair et plus rapide.
D’autres fonctionnalités liées aux boucles sont l’instruction
> repeat expr
et l’instruction
> while (condition) expr
L’instruction break peut être utilisée dans toutes ces boucles. C’est la seule
faon de terminer une boucle repeat.
L’instruction next peut être utilisée pour sauter une étape et passer à la suivante.
Les instructions de contrôle sont souvent utilisées avec des fonctions qui sont détaillées dans
hundefinedi [Ecrire vos propres fonctions], page hundefinedi , chapitre dans lesquels d’uatres
exemples seront développés.
Chapitre 8: Ecrire des fonctions
29
8 Ecrire des fonctions
Comme nous l’avons déjà vu de faon informelle, le langage R permet à l’utilisateur de
créer des objets de mode fonction. Celles-ci sont des fonctions R qui sont stockées en interne
de faon appropriée et qui peuvent être utilisées dans des expressions etc. Avec ce procèdé,
le langage gagne en puissance, élégance et facilité d’utilisation. Apprendre à écrire des
fonctions utiles est l’une des faons d’utiliser R de faon confortable et productive.
Il faut préciser que la plupart des fonctions faisant partie du système R, comme mean(),
var(), postscript() etc. sont elle-même écrites en R et ne diffèrent pas des fonctions
utilisateur de ce point de vue.
Une fonction est définie par une affectation de la forme :
> nom <- function(arg 1, arg 2, ...) expression
L’expression est une expression R, habituellement un groupe d’expressions, qui utilise
les arguments arg i pour calculer une valeur résultat. Le résultat de l’expression (ou du
groupe d’expressions) est le résultat retourné par la fonction. Un appel de fonction est en
général de la forme nom(expr 1, expr 2, ...) et peut se faire partout ou cela est légitime.
8.1 Exemples simples
Comme premier exemple, considèrons une fonction qui calcule la statistique de fisher en
montrant bien toutes les étapes. C’est bien sr un exemple artificiel car il y a d’autres faons
plus simples de faire la même chose (fonction t.test par ex.).
8.2 Définir de nouveaux opérateurs binaires
8.3 Arguments nommés et arguments par défaut
8.4 L’argument ‘...’
8.5 Affectations dans les fonctions
Chapitre 9: Procèdures graphiques
30
9 Procèdures graphiques
Les fonctionnalités graphiques sont un composant important et très modifiable de
l’environnement R. Il est possible d’utiliser ces fonctionnalités pour produire une large
varièté de graphiques statistiques mais aussi pour construire de nouveaux types de
graphiques.
Les fonctionnalités graphiques peuvent être utilisée autant en mode interactif qu’en
mode batch, mais le mode interactif est dans la plupart des cas le plus utile. L’utilisation
interactive est également facile car au démarrage R lance un device driver graphique qui
ouvre au besoin des fenêtres graphiques pour l’affichage des graphiques interactifs. Même si
cela se fait fait automatiquement, il est utile de savoir que la fonction X11() est employée
sous UNIX et window() sous Windows.
Une fois que le device driver est en marche, Les commandes graphiques peuvent être
utilisées pour produire et créer des graphes.
Les commandes graphiques sont divisées en trois grands groupes :
• Les fonctions graphiques de haut-niveau créent un nouveau graphe sur la fenêtre
graphique, avec éventuellement des axes, des labels, des titres etc.
• Les fonctions graphiques de bas niveau rajoutent de l’information à un graphe existant,
comme des points supplémentaires, des lignes ou des labels.
• Les fonctions graphiques interactives permettent de rajouter, ou d’enlever, de
l’information sur un graphe existant de faon interactive, à l’aide d’un mécanisme de
pointage, comme la souris.
En supplément, R garde une liste des paramètres graphiques qui peuvent être manipulés
pour personnaliser vos graphes.
9.1 Commandes graphiques de haut niveau
Les fonctions graphiques de haut-niveau sont prévues pour générer un graphe complet
à partir des données passées en argument de la fonction.Quand c’est approprié, des axes,
labels et titres sont automatiquement générés (à moins que vou n’ayez spécifié le contraire).
Les commandes graphiques de haut niveau démarrent toujours un nouveau graphe, effaant
le graphe courant si nécessaire.
9.1.1 La fonction plot
Une des fonctions graphiques les plus utilisées en R est plot(). C’est une fonction
générique : le type de graphe produit dépend du type ou classe du premier argument.
plot(x,y)
plot(xy) si x et y sont des vecteurs, plot(x,y) produit un graphe des avec les coordonnées de x en abscisse et les coordonnées de y en ordonnée. On peut obtenir
le même résultat en fournissant un seul argument (seconde forme) qui soit une
liste de deux éléments x et y ou une matrice à deux colonnes.
plot(x)
si x est une série temporelle, cela produit un graphe série-temporelle, si x est
un vecteur numérique, cela produit un graphe des coordonnées de x contre leur
31
indice dans le vecteur, et si x est un vecteur complexe, cela produit un graphe
des parties imaginaires des éléments du vecteur contre les parties réelles.
plot(f )
plot(f,y) f est un facteur, y un vecteur numérique. La première forme gnère un diagramme en batons de f ; la seconde forme produit des boîtes à pattes de y pour
chaque niveau de f.
plot(jd)
plot(~ expr)
plot(y ~ expr)
jd est un jeu de données, y est un objet, expr est une liste de noms d’objets
séparée par ’+’ (e.g., a+b+c). Les deux premières forms produisent des graphes
des distributions des variables dans le jeu de données (première forme) ou d’un
certain nombre d’objets nommés (seconde forme). La troisième forme dessine
y contre chaque objet nommé dans expr.
9.1.1.1 graphes de données multivariées
R fournit deux fonctions très utiles pour représenter des données multivariées. Si X est
une matrice numérique ou un jeu de données, la commande
> pairs(X)
produit une matrice des diagrammes de dispersion définie par les colonnes de X, c’est à
dire que chaque colonne de X est dessinée contre chaque autre colonne de X et les n(n-1)
graphes sont placés dans une matrice avec la mme échelle dans les lignes et colonnes de la
matrice. Le nom de pairs vient du fait que’il y a un diagramme de dispersion pour chaque
paire de colonnes de X. Quand on travaille avec trois ou quatre variables, un coplot peut
être plus enrichissant. si a et b sont deux vecteurs numériques et c est un vecteur numérique
ou un facteur (tous de la même longueur), alors la commande
> coplot(a ~ b | c)
produit des graphes de a contre b pour des valeurs de c données. Si c est un facteur,
cela signifies simplement que a est dessiné contre b pour chaque niveau de c. Quand c
est numérique, il est divisé en un certain nombre d’intervalles de conditionnement et pour
chaque intervalle, a est dessiné contre b pour chaque valeur de c dans l’intervalle. Le
nombre et la position des intervalles peuvent être controllés via l’argument given.values=
de coplot()—la fonction co.intervals() est utile pour sélectionner les intervalles. Vous
pouver aussi donner 2 variables conditionnantes avec une commande comme
> coplot(a ~ b | c + d)
qui produit des graphes de dispersion de a contre b pour chaque intersection des intervalle
conditionnant de c et d.
Les fonctions coplot() et pairs() prennent toutes les deux un argument panel= qui
peut être utilisée pour définir le type de graphe qui apparaît dans chaque cadre. Le défaut
est points() pour produire un dessin des points sur un plan, mais en fournissant d’autres
fonctions graphiques de bas niveau à panel=, vous pouvez dessiner n’importe quel type de
graphe.Un exemple de fonction utile pour les coplot est panel.smooth().
32
9.1.2 Graphiques spéciaux
D’autres fonctions graphiques de haut niveau produisent des types de graphes différents.
Quelques exemples :
qqnorm(x)
qqline(x)
qqplot(x, y)
Graphiques de comparaison de distributions. La première forme trace le vecteur
numŕique x contre les scores attendus d’une normale (graphe qq) et le deuxième
ajoute une ligne à ce graphe qui passe à travers les quartiles de la distribution
et des données. La troisième forme dessine les quartiles de x contre ceux de y
pour comparer leur distributions respectives.\
hist(x)
hist(x, nclass=n)
hist(x, breaks=b, ...)
Produit l’histogramme du vecteur numérique x. Un nombre de classes adéquat
est géneralement choisi, mais on peut donner une recommandation a travers
l’argument nclass=. On peut également choisir de donner les points de rupture avec l’argument breaks=. Si probability=TRUE est donné, les barres
représentent les fréquences relatives au lieu de comptage.
dotchart(x, ...)
construit un graphique en épingle (?) des donnees de x. Dqns un graphique
en épingle (?), on a en ordonnée les labels des données de x et les valeurs en
abscisse. Par exemple cela permet une sélection visuelle facile de données dont
les valeurs sont dans une certaine fourchette.
image(x, y, z, ...)
contour(x, y, z, ...)
persp(x, y, z, ...)
Graphes tridimensionnels. le graphe image dessine une grille de rectangles de
differentes couleurs pour representer les valeurs de z, le graphe contour des
lignes, et persp dessine une surface 3D.
9.1.3 Arguments des fonctions graphiques de haut niveau
Un grand nombre d’arguments peuvent être passés aux fonctions graphiques de haut
niveau :
add=TRUE
Obliges la fonction à agir comme une fonction graphique de bas niveau, ajoutant
le graphe sur le graphe courant (seulement pour certaines fonctions).
axes=FALSE
ne génère pas les axes—utile pour ajouter vos axes personnalisés avec la fonction
codeaxis(). Par défaut , axes=TRUE, les axes sont génèrés.
log="x"
log="y"
log="xy"
les abscisses, les ordonnées ou les deux sont logarithmiques. Ceci marchera pour
beaucoup de fonctions (pas toutes...).
type=
33
l’argument type= contrôle le type de graphe produit, de la façon suivante :
type="p"
Dessine des points individuels (le défaut)
type="l"
Dessine des lignes
type="b"
Dessine des points connectés par des lignes (both)
type="o"
dessine des points traversés par des lignes.
type="h"
dessine des points reliés à l’axe des ordonnees par des lignes verticales (high-density)
type="s"
type="S"
type="n"
fonctions en escalier. (...)
Ne dessine rien. Cependant les axes sont génerés (par défaut) et le
système de coordonnées est mis en place en fonction des données.
Idéal pour creer des graphes avec les fonctions graphiques de bas
niveau par la suite.
xlab=string
ylab=string
Légendes des axes des abscisses et des ordonnées. utilisez ces arguments pour
changer les légendes par défaut, habituellement les noms des objets dans l’appel
de la fonction.
main=string
Titre de la figure, placé au dessus de cette dernière, en grosses lettres.
sub=string
Sous-titre, place juste sous l’axe des abscisses dans une police plus petite.
9.2 Fonctions graphiques de bas niveau
Parfois les fonctions graphiques de haut niveau ne produisent pas exactement
le type de graphe que l’on recherche. Dans ce cadre, les fonctions graphiques
de bas niveau peuvent être utilisées pour rajouter de l’information (comme des
points, des lignes, du texte) au graphique courant.
Parmi les plus utiles de ces fonction graphiques de bas niveau on a :
points(x, y)
lines(x, y)
Rajoutes des points ou des lignes au graphique courant. l’argument
type= de plot() peut egalement etre passes a ces fonctions (par
defaut il est a "p" pour points() et "l" pour lines().)
text(x, y, labels, ...)
Ajoutes du texte au graphique aux points donnés par x, y. Normalement labels est un vecteur de caractères ou d’entiers, et
labels[i] est ajouté à la position (x[i], y[i]).
Note: Cette fontion est souvent utilisée comme suit
34
> plot(x, y, type="n"); text(x, y, names)
Le paramètre graphique type="n" supprime les points mais dessine
les axes, et la fonction text() dessine les caracteres spéciaux donnés
par names aux emplacements des points.
abline(a, b)
abline(h=y)
abline(v=x)
abline(lm.obj)
Rajoutes une ligne de pente b et d’abscisse à l’origine a au graphe
courant. (...)
polygon(x, y, ...)
Dessines un polygone défini par les vecteurs ordonnés (x, y) et
(optionnellement) le remplit de hachures.
legend(x, y, legend, ...)
Ajoutes une légende au graphe courant à la position spécifiée. les
caractères utilisés pour les points, les styles de lignes etc. sont
identifiés par les labels du vecteur legend. Au moins un argument
v (de la même taille que legend) avec les valeurs correspondantes
doit être donné :
legend( , fill=v)
Couleurs pour des remplissages
legend( , col=v)
Couleurs des points ou lignes
legend( , lty=v)
Styles des lignes
legend( , lwd=v)
Epaisseurs des lignes
legend( , pch=v)
Type des points (vecteur de caractères)
title(main, sub)
Ajoute un titre main en haut du graphe courant en grande police
et (optionnellement) un sous-titre sub en bas avec une police plus
petite.
axis(side, ...)
Ajoutes un axe au graphe courant sur le coté donné par le premier
argument (1 à 4 en partant du bas dans le sens des aiguilles d’une
montre.) Les autres arguments contrôlent la position de l’axe, les
marques et les labels. Utile pour ajouter des axes personnalisés en
utilisant plot() avec l’argument axes=FALSE.
Les fonctions graphiques de bas niveau nécessitent en général des informations
de position (e.g., les coordonnees x et y) pour déterminer ou placer les nouveaux
eléments graphiques. Les coordonnées sont alors des coordonnées utilisateur qui
35
sont définies par les fonctions graphiques de haut niveau utilisées précédemment
et choisies en fonction des données fournies.
Quand les arguments x et y sont nécessaires, il est également possible de fournir
une liste avec deux éléments codex et y. On peut également fournir une matrice
avec deux colonnes. Ainsi des fonctions comme locator() (voir ci-dessous)
peuvent servir a donner des positions de façon interactive.
9.2.1 Annotation mathématique
Il est parfois utile djouter des symboles mathématiques et des formules àun
graphique. On peut faire cela en R en donnant une expression en argument de
text, mtext, axis, ou title au lieu d’une chaîne de caractères. Par exemple
le code suivant dessine la formule de la distribution d’une binomiale :
> text(x, y, expression(paste(bgroup("(", atop(n, x), ")"),
p^x, q^{n-x})))
Pour plus d’informations, y compris une liste complète des possibilités
disponibles, on peut utiliser les commandes R :
> help(plotmath)
> example(plotmath)
9.2.2 Polices Hershey vectorielles
Il est possible de spécifier une police vectorielle Hershey pour le texte qaund on
utilise les fonctions text et contour. Trois raisons d’utiliser ces polices Hershey
:
• Les polices Hershey rendent mieux, particuliérement á lècran, pour du text
renversé et/ou en petits caractères.
• Les polices Hershey fournissent des symboles qui ne sont pas disponibles
avec les polices classiques. En particulier certains signes du zodiaque, des
symboles cartographiques et astronomiques.
• Les polices Heshey fournissent les caractères japonais (kana et kanji).
Pour plus d’informations, y compris les tables des caractères Hershey, on peut
utiliser les commandes R :
> help(Hershey)
> example(Hershey)
> help(Japanese)
> example(Japanese)
9.3 Interragir avec les graphiques
R propose également des fonctions permettant à l’utilisateur d’ajouter ou
d’extraire des information d’un graphe avec la souris. La plus simple est la
fonction locator() :
locator(n, type)
Attends que l’utilisateur sélectionne un point du graphe courant
avec le bouton gauche de la souris. Ceci jusqu’a ce que n (512
36
par défaut) points aient été sélectionnés, ou jusqu’a ce qu’on clique
avec un autre bouton de la souris (Unix, Windows), ou en dehors
de la fenêtre (Mac). L’argument type permet de dessiner les points
selectionnés et a le même effet que pour les commandes graphiques
de haut niveau; par défaut, ne dessine pas les points. locator()
renvoie les coordonnées des points selectionnés dans une liste avec
deux composants x et y.
locator() est généralement appelé sans arguments. C’est une fonction bien
utile pour selectionner les position d’éléments graphiques comme des labels ou
des légendes quand il est compliqué de prévoir à l’avance où sera les graphe.
Par exemple, pour placer un texte informatif près d’un individu aberrant, on
peut faire :
> text(locator(1), "Aberrant", adj=0)
locator() marche également dans le cas ou la souris n’est pas disponible ; dans
ce cas l’utilisateur sera invité à saisir ses coordonnèes x et y.
identify(x, y, labels)
Permet à l’utilisateur de mettre en lumière un point défini par x
et y (avec le bouton gauche de la souris) en dessinant à coté le
composant de labels correspondant (ou l’indice du point si labels
est absent). Retournes les indices des points selectionnés quand on
clique avec un autre bouton (Unix, Windows) ou en dehors de la
fenêtre (Mac).
Parfois on veut identifier des points particuliers du graphe plutot que leurs
positions. Par exemple on peut vouloir que l’utilisateur selectionne certaines
observations d’interert sur un graphique pour les manipuler par la suite. Etant
donnés des coordonnées (x, y) données dans deux vecteurs numériques x et y,
on peut utiliser la fonction identify() comme suit :
> plot(x, y)
> identify(x, y)
identify() ne dessine rien par elle-même mais elle permet à l’utilisateur de
cliquer avec le bouton gauche de la souris près d’un point. Le point le plus
proche de la souris sera alors mis en lumière par son indice (c’est à dire sa
position dans les vecteurs x/y) imprimé juste à coté. On peut également fournir
une chaine de caractères plus informative en utilisant l’argument labels de
identify(), ou désactiver la mise en lumière avec l’argument plot=FALSE.
Quand le processus se termine (voir plus haut), identify() renvoies les indices
des points selectionnés; vous pouvez utiliser ces indices pour extraire les points
des vecteurs x et y.
9.4 Paramètres graphiques
Quand on crée des graphes, spécialement dans un objectif de présentation ou de
publication, R ne produit pas toujours exactement ce que l’on veut. Cependant
vous pouvez personnaliser presques tous les aspects d’une fenêtre graphique en
utilisant les Paramètres graphiques. R possède une grande varièté de paramètres
37
graphiques qui controlent des choses comme le style des lignes, les couleurs,
arrangement des figures et la justification du texte parmi tant d’autres. Chaque
paramètre graphique a un nom (comme ‘col’, qui contrôle les couleurs), et une
valeur (un numéro de couleur, par exemple).
Une liste de paramètres graphique est tenue à jour pour chaque graphe actif,
et chaque graphe a un jeu de paramètres par défaut quand il est initialisé. Les
paramètres graphiques peuvent être définis de deux façons : soit permanente,
affectant toutes les fonctions graphiques qui dessinent dans la fenêtre courante;
soit temporaire, affectant un unique appel de fonction graphique.
9.4.1 Changements permanents : la fonction par()
On utilise la fonction par() pour modifier ou accèder à une liste de tous les
paramètres graphiques et leurs valeurs pour le graphe courant.
par()
Sans arguments, renvoie une liste de tous les paramètres graphiques
et leurs valeurs pour le graphe courant.
par(c("col", "lty"))
Avec un vecteur de caractères en argument, renvoie seulement les
paramètres graphiques donnés (ici encore sous forme de liste).
par(col=4, lty=2)
Avec des arguments nommés (ou une liste), modifie les valeurs des
paramètres graphiques donnés, et retournes les valeurs originales
des paramètres dans une liste.
Ajuster les paramètres graphiques avec la fonction par() change les valeurs
des paramètres de façon permanente en ce sens que des appels futurs à des
fonctions graphiques (dans la fenêtre courante) seront affectés par ces nouvelles
valeurs. En fait quand on initialise les paramètres de cette façon, on doit y
penser comme à la mise en place de valeurs par "défaut" qui seront utilisées
par les fonctions graphiques à moins qu’une valeur alternative soit donnée.
Notez que les appels à par() affectent toujours les valeurs globales des
paramètres graphiques, même quand par() est appelé dans une fonction.
C’est souvent un comportement indésirable—en général, on veut modifier
certains paramètres graphiques, faire des graphes, puis revenir aux valeurs
originales sans affecter la session R. Vous pouvez revenir aux valeurs initiales
en sauvant le résultat de par() en faisant les changements, et en restaurant
les valeurs initiales une fois le graphe achevé.
> vieuxpar <- par(col=4, lty=2)
. . . commandes graphiques . . .
> par(vieuxpar)
9.4.2 Changements temporaires : arguments des
fonctions graphiques
Les paramètres graphiques peuvent aussi être passés à (presque) toutes les fonctions graphiques comme des arguments nommés. Cela à les mêmes effets que de
38
passer les argments à la fonction par() sauf que les changements ne dureront
que le temps de l’appel de la fonction. Par exemple :
> plot(x, y, pch="+")
produit un nuage de points en utilisant un signe plus comme caractère
d’impresion des points, sans changer le caractère d’impression par défaut pour
de futurs graphes.
9.5 Liste des paramètres graphiques
La section qui suit détaille beaucoup des paramètres graphiques les plus utilisés
au niveau utilisateur. La documentation R de la fonction par() fournit un
résumé plus concis; on propose ici une alternative un peu plus détaillée.
Les paramètres graphiques seront proposés sous la forme suivante :
nom=valeur
Une description de l’effet du param‘etre. nom est le nom du
paramètre, c’est à dire le nom de l’argument à utiliser dans les
appels à par() ou à des fonctions graphiques. valeur est une
valeur typiquement utilisée pour initialiser le paramètre.
9.5.1 Eléments graphiques
les graphes de R sont faits de points, de lignes, de texte, et de polygones (régions
pleines). Il existe des paramètres graphiques qui contrôlent la façon dont ces
élements graphiques sont dessinés :
pch="+"
Le caractère à utiliser pour le dessin des points. Le défaut varie
suivant les pilotes, mais en général c’est ‘◦’. Les points dessinés ont
tendance à apparaître au dessus ou au dessous de la vraie position,
à moins d’utiliser "." comme caractère de dessin, ce aui donne des
points bien centrés.
pch=4
Quand pch est donné par un entier compris entre 0 et 18, un symbole spécial est utilisé. Pour voir quels sont ces symboles, utilisez
la commande
> legend(locator(1), as.character(0:18), pch = 0:18)
lty=2
Type des lignes. Les styles de lignes ne sont pas supportés par tous
les pilotes graphiques (et varient suivant ceux qui les supportent)
mais une ligne de type 1 est toujours continue et les lignes au dessus
du type 2 sont plus ou moins pointillées.
lwd=2
Largeur des lignes. La largeur de ligne désirée, en multiples de la
largeur de ligne "standard". Affecte les axes autant que les lignes
dessinées avec lines(), etc.
col=2
Les couleurs à utiliser pour les points, les lignes, le texte, les régions
pleines et les images. Chacun de ces élements graphiques a une liste
de couleurs possibles et la valeur de ce paramètre est un indice de
cette liste. Ce paramètre ne s’applique bien sûr que pour un nombre
limité de périphériques graphiques.
font=2
39
Un entier qui spécifie la police à utiliser pour le texte. Si c’est possible, les pilotes de périphériques s’arrangent pour que 1 corresponde
à du texte normal, 2 à du gras, 3 à de l’italique et 4 à de l’italique
gras.
font.axis
font.lab
font.main
font.sub La police à utiliser pour l’annotation des axes, les labels des abscisses et des ordonnées, les titres principaux et les sous-titres respectivement.
adj=-0.1
La justification du texte relativement au dessin. 0 signifies justification à gauche, 1 à droite et 0.5 signifies que l’on centre horizontalement autour de la position de dessin. La valeur est en fait la
proportion de texte qui apparait à gauche de la position de dessin,
ainsi une valeur de -0.1 laisse un vide de 10% de la taille du texte
entre le texte et la position de dessin.
cex=1.5
Agrandissement de caractères. La valeur est la taille de caractères
désirée (y compris les caractères de dessin) relativement a la taille
du texte par défaut.
9.5.2 Axes et marques
Beaucoup des graphiques de haut niveau de R ont des axes, et l’on peut construire ses propres axes avec la fonctions graphique de bas niveau axis(). Les axes
ont trois composantes principales : les lignes d’axe (dont le style est controlé
par le paramètre graphique lty), les marques d’axe (qui marquent les unités de
l’axe) et les labels de marques (sic) (qui identifient les unités). Ces composantes
peuvent être personnalisées à l’aide des paramètres graphiques suivants.
lab=c(5, 7, 12)
Les deux premiers chiffres indiquent le nombre d’intervalles de marques sur les axes des abscisses et des ordonnées respectivement. Le
troisième chiffre e est la longueur, en caractères, des labels des axes
(en incluant le point des décimales). Si on choisit une valeur trop
petite pour ce paramètre, on peut se retrouver avec tous les labels
arrondis au même chiffre!
las=1
Orientation des labels des axes. 0 signifie parallèle à l’axe, 1 horizontal, et 2 perpendiculaire à l’axe.
mgp=c(3, 1, 0)
Positions des composantes des axes. Le premier paramètre est la
distance entre l’axe son intitulé, en lignes de texte. Le deuxième est
la distance aux labels des marques, et le dernier est la distance de
la position de l’axe à la ligne d’axe (en général 0). Nombres positifs
pour l’extérieur de la région graphique et négatifs pour l’intérieur.
tck=0.01
Longueur des marques, en fraction de la taille de la région
graphique. Quand tck est petit (plus petit que 0.5) les marques
40
des abscisses et des ordonnées sont forcées à la même taille. Une
valeur de 1 donne une grille. Les valeurs négatives donnent
des marques en dehors du graphique. Utilisez tck=0.01 et
mgp=c(1,-1.5,0) pour des marques à l’intérieur de la ligne d’axe.
xaxs="s"
yaxs="d"
Le style des axes pour les abscisses et des ordonnées respectivement.
Avec les styles "s" (standard) et "e" (étendu) la plus petite marque
et la plus grande sont en dehors du domaine des données. Les axes
étendus peuvent être rallongés si il y a des points trs̀ proches des
bords. Ce type d’axe peut laisser de larges espaces vides près des
bords. Avec les styles "i" (interne) et "r" (le défaut) les marques
sont toujours dans le domaine des données, et le style "r" laisse
toujours un espace vide sur les bords.
Règler ce paramètre sur "d" (axe dircet) bloque l’axe courant et
l’utilise pour les graphes suivants (ou au moins jusqu’à ce que le
paramètre soit reinitialisé à une des valeurs ci-dessus). Utile pour
génerer une série de graphes à la même échelle.
9.5.3 Marges des figures
Un graphe seul en R est appelé figure et comprends une région graphique
entourée de marges (contenant éventuellement les intitulés des axes, les titres,
etc.) et (généralement) délimitée par les axes eux-mêmes.
Une figure typique
mar[3]
3.0
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
−−−−−−−−−−−−−−−−−−
y
0.0
1.5
Plot region
−3.0
−1.5
mai[2]
−3.0
−1.5
mai[1]
0.0
x
1.5
3.0
Margin
Les paramt̀res graphiques contrôlant tout ceci incluent :
mai=c(1, 0.5, 0.5, 0)
Les largeurs des marges du bas, de gauche, du haut et de droite
respectivement, en pouces.
41
mar=c(4, 2, 2, 1)
Pareil que mai sauf que l’unité est ici la ligne de texte au lieu du
pouce.
mar et mai sont équivalents au sens ou modifier l’un modifies aussi l’autre. Les
valeurs par défaut pour ces paramètres sont souvent trop grandes; la marge de
droite est rarement utile et celle du haut ne l’est jamais s’il n’y a pas de titre. Les
marges du bas et de gauche doivent être assez larges pour les axes et les intitulés
des marques. De plus le défaut est défini sans prendre en compte la taille de
la surface du graphe : par exemple en employant le pilote postscript() avec
l’argument height=4 resultera en un graphe occupé à 50% par les marges à
moins que mar ou mai soient donnés explicitement. Quand on a des matrices
de figures (voir plus loin) les marges sont réduites de moitié mais cela peut être
encore trop large siil y a beaucoup de figures sur la même page.
9.5.4 Matrices de graphiques
9.5.5 Pilotes de périphériques
9.5.6 Diagrammes postscript
9.6 Graphiques dynamiques
Annexe A: Une session d’introduction à R
42
Annexe A Une session d’introduction à R
La session qui va suivre se propose de vous présenter certaines fonctionnalités de
l’environnement R par la pratique. De nombreuses fonctionnalités sembleront déroutantes
au premier abord, mais cela disparaitra avec l’usage. Ceci est écrit pour l’utilisateur UNIX
, ceux qui utilisent Windows devront adapter un peu.
Loggez-vous et démarrez votre gestionnaire de fenêtres. Vous devez avoir le
fichier ‘morley.data’ dans votre répertoire de travail. Si ce n’est pas le cas,
addressez-vous à votre responsable système (si vous avez la chance d’en avoir
un;) ou prenez-la directement dans le répertoire ‘base/data’ de la bibliothque
R (dans ‘/usr/local/R’ par exemple).
$R
Démarre R.
Le programme R commence, avec un bandeau de commentaires..
(Par la suite le prompt de R ne sera pas représenté pour éviter les confusions.)
help.start()
Démarre l’aide html (en utilisant un butineur disponible sur votre machine).
Vous pouvez regarder un peu les différentes possibilités pour obtenir de l’aide.
Iconifiez ensuite la fenêtre.
x <- rnorm(50)
y <- rnorm(x)
Génère 2 vecteurs x et y pseudo-aléatoires de loi normales et de longueur 50.
plot(x, y)
dessine les points dans le plan. une fenre graphique apparaitra automatiquement.
ls()
Visualise les objets qui sont dans l’espace de travail de R.
rm(x,y)
supprime les objets dont on n’a plus besoin.
x <- 1:20 Crée x = (1, 2, . . . , 20).
w <- 1 + sqrt(x)/2
Cre un vecteur de ’poids’ (écarts types) w.
dummy <- data.frame(x=x, y= x + rnorm(x)*w)
dummy
Construit un data frame de 2 colonnes, x et y, et regarde ce qu’il y a dedans..
fm <- lm(y ~ x, data=dummy)
summary(fm)
Regression linéaire de y sur x et affichage de l’analyse.
fm1 <- lm(y ~ x, data=dummy, weight=1/w^2)
summary(fm1)
Vu qu’on connait les écarts types, on peut faire une regression pondérée.
attach(dummy)
Rends les colonnes du data frame visibles comme des variables.
lrf <- lowess(x, y)
Régression non-paramètrique.
43
plot(x, y)
Graphique standard.
lines(x, lrf$y)
Ajoute la courbe de régression au graphe.
abline(0, 1, lty=3)
La vraie droite de régression : (ordonnée à l’origine 0, pente 1).
abline(coef(fm))
La droite de la régression non-pondérée.
abline(coef(fm1), col = "red")
La droite de la régression pondérée.
detach()
Enlève le data frame de la search list.
plot(fitted(fm), resid(fm),
xlab="Fitted values",
ylab="Residuals",
main="Residuals vs Fitted")
Un diagnostique graphique standard de régression pour confirmer ou infirmer
l’hypothèse d’hétéroscédasticité. Pouvez-vous le voir ?
qqnorm(resid(fm), main="Residuals Rankit Plot")
Un graphe de normalité des scores pour repèrer les individus aberrants (pas
très utile dans ce cas).
rm(fm, fm1, lrf, x, dummy)
On refait le ménage...
On étudiera dans la section qui vient des données provenant des expériences de Michaelson et Morley ayant pour but de mesurer la vitesse de la lumière.
file.show("morley.tab")
Optionnel. Interromp temporairement R et consulte le fichier.
mm <- read.table("morley.tab")
mm
enregistre les données de Michaelson et Morley comme data frame, et le consulte. Il y a cinq expériences (colonne Expt) répétés 20 fois (colonne Run) et sl
est la vitesse de la lumière enregistrée.
mm$Expt <- factor(mm$Expt)
mm$Run <- factor(mm$Run)
Change Expt et Run en facteurs.
attach(mm)
rends le data frame visible en position 2 (le défaut).
plot(Expt, Speed, main="Speed of Light Data", xlab="Experiment No.")
Compare les 5 expériences avec des botes à moustaches.
fm <- aov(Speed ~ Run + Expt, data=mm)
summary(fm)
Analyse de la variance, avec ‘runs’ et ‘experiments’ comme facteurs.
44
fm0 <- update(fm, . ~ . - Run)
anova(fm0,fm)
Ajuste un sous modèle en omettant ‘runs’, puis le compare à l’autre.
detach()
rm(fm, fm0)
Fait le ménage avant la suite.
We now look at some more graphical features: contour and image plots.
x <- seq(-pi, pi, len=50)
y <- x
x is a vector of 50 equally spaced values in −π ≤ x ≤ π. y is the same.
f <- outer(x, y, function(x, y) cos(y)/(1 + x^2))
f is a square matrix, with rows and columns indexed by x and y respectively,
of values of the function cos(y)/(1 + x2 ).
oldpar <- par(no.readonly = TRUE)
par(pty="s")
Save the plotting parameters and set the plotting region to “square”.
contour(x, y, f)
contour(x, y, f, nlevels=15, add=TRUE)
Make a contour map of f ; add in more lines for more detail.
fa <- (f-t(f))/2
fa is the “asymmetric part” of f . (t() is transpose).
contour(x, y, fa, nint=15)
Make a contour plot, . . .
par(oldpar)
. . . and restore the old graphics parameters.
image(x, y, f)
image(x, y, fa)
Make some high density image plots, (of which you can get hardcopies if you
wish), . . .
objects(); rm(x, y, f, fa)
. . . and clean up before moving on.
R can do complex arithmetic, also.
th <- seq(-pi, pi, len=100)
z <- exp(1i*th)
1i is used for the complex number i.
par(pty="s")
plot(z, type="l")
Plotting complex arguments means plot imaginary versus real parts. This
should be a circle.
w <- rnorm(100) + rnorm(100)*1i
Suppose we want to sample points within the unit circle. One method would be
to take complex numbers with standard normal real and imaginary parts . . .
45
w <- ifelse(Mod(w) > 1, 1/w, w)
. . . and to map any outside the circle onto their reciprocal.
plot(w, xlim=c(-1,1), ylim=c(-1,1), pch="+",xlab="x", ylab="y")
lines(z)
All points are inside the unit circle, but the distribution is not uniform.
w <- sqrt(runif(100))*exp(2*pi*runif(100)*1i)
plot(w, xlim=c(-1,1), ylim=c(-1,1), pch="+", xlab="x", ylab="y")
lines(z)
The second method uses the uniform distribution. The points should now look
more evenly spaced over the disc.
rm(th, w, z)
Clean up again.
q()
Quit the R program. You will be asked if you want to save the R workspace,
and for an exploratory session like this, you probably do not want to save it.
Annexe B: Index des variables et fonctions
46
Annexe B Index des variables et fonctions
!
<
! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
!= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
< . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
<= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
&
& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
&& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
*
* ............................................ 8
- ............................................ 8
A
abline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
as.data.frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
attr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
axis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34
21
15
15
34
B
break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
/
/ ............................................ 8
:
: ............................................ 9
C
c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 20
contour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
coplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
cos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
=
== . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
?
? ............................................ 4
|
| . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
|| . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
D
data.entry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
data.frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
dotchart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
20
25
32
E
else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
exp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
+
+ ............................................ 8
F
>
fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
>= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
H
^
^ ............................................ 8
help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
hist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Annexe B: Index des variables et fonctions
I
identify. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ifelse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
is.na . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
is.nan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
Q
36
27
27
32
10
10
L
legend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
levels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
locator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
qqline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
qqnorm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
qqplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
R
range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
read.table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
rep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
rm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
S
N
scan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
seq . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
sin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
sink . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
sqrt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
NA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
next . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
T
M
max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
mean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
O
order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
ordered . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
ordonne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
tan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
tapply . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
title . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
U
P
pairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
par . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
persp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
pmax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
pmin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
polygon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
prod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
unclass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
V
var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
W
while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Annexe C: Index des concepts
48
Annexe C Index des concepts
A
I
Accèder aux jeux de données de base . . . . . . . . . . 25
Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Importer des données . . . . . . . . . . . . . . . . . . . . . . . . 26
Instructions de controle . . . . . . . . . . . . . . . . . . . . . . 27
B
Boucles et execution conditionnelle . . . . . . . . . . . . 27
D
Data frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
E
Ecrire des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Espace de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Expressions groupees . . . . . . . . . . . . . . . . . . . . . . . . . 27
L
lire des donnees dans des fichiers . . . . . . . . . . . . . . 23
Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
P
Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Paramètres graphiques . . . . . . . . . . . . . . . . . . . . . . . 37
R
Rediriger les entrées et les sorties . . . . . . . . . . . . . . 5
regle de recyclage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
S
Supprimer des objets . . . . . . . . . . . . . . . . . . . . . . . . . . 6
F
Facteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Facteurs ordonnes . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Fonctions arithmetiques et operateurs . . . . . . . . . . 8
V
Valeurs manquantes . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Vecteurs de caractères . . . . . . . . . . . . . . . . . . . . . . . . 10
Annexe D: Références
49
Annexe D Références
D. M. Bates and D. G. Watts (1988), Nonlinear Regression Analysis and Its Applications.
John Wiley & Sons, New York.
Richard A. Becker, John M. Chambers and Allan R. Wilks (1988), The New S Language.
Chapman & Hall, New York. Ce livre est souvent appel le “Blue Book ”.
John M. Chambers and Trevor J. Hastie eds. (1992), Statistical Models in S. Chapman
& Hall, New York. Aussi appel le “White Book ”.
Annette J. Dobson (1990), An Introduction to Generalized Linear Models, Chapman and
Hall, London.
Peter McCullagh and John A. Nelder (1989), Generalized Linear Models. Second edition,
Chapman and Hall, London.
John A. Rice (1995), Mathematical Statistics and Data Analysis. Second edition.
Duxbury Press, Belmont, CA.
S. D. Silvey (1970), Statistical Inference. Penguin, London.

Une introduction `a R

Transcription

Documents pareils

Tre Bicchieri Gambero Rosso Tre Bicchieri Gambero Rosso DRO IT d

Schubert Ave Maria (French).mus

Le banc de l`amitié

Comment m`est venu l`amour des mathématiques En 1961–62, j

Comme lui Robert Lebel - Partition de chant liturgique gratuite

Insecticide liquide contre les mouches dans l

09_la_croisade_des_enfants_-_jacques_higelin ( PDF

Ave Maria

Présentation du logiciel R

formulaire - pdf - (GTAA) Mulhouse 26