INTRODUCTION R

AXE MSA septembre 2005

Prambule .......................................................................................................................... 3 Spcificits de R ............................................................................................................ 3

Comment a fonctionne ......................................................................................................... 3 Crer, lister et effacer les objets en mmoire ......................................................................... 4 Laide en ligne........................................................................................................................ 5 Les donnes avec R ................................................................................................... 6 Les objets................................................................................................................................ 6 Lire des donnes dans un fichier ............................................................................................ 7 Enregistrer les donnes........................................................................................................... 8 Gnrer des donnes............................................................................................................... 8 Squences rgulires .......................................................................................................... 8 Squences alatoires........................................................................................................... 9 Manipuler les objets ............................................................................................................. 10 Cration dobjets .............................................................................................................. 10 Les oprateurs .................................................................................................................. 12 Accder aux valeurs dun objet : le systme dindexation............................................... 13 Accder aux valeurs dun objet avec les noms ................................................................ 14 Calcul arithmtique et fonctions simples ......................................................................... 14 Calcul matriciel ................................................................................................................ 15 Les graphiques avec R ........................................................................................... 16 Gestion des graphiques......................................................................................................... 16 Ouvrir plusieurs dispositifs graphiques............................................................................ 16 Partitionner un graphique ................................................................................................. 16 Les fonctions graphiques...................................................................................................... 17 Un exemple concret.............................................................................................................. 18 Les packages grid et lattice .................................................................................................. 19 Les packages ........................................................................................................................ 21 Programmer avec R .................................................................................................. 22 Boucles et vectorisation ....................................................................................................... 22 Ecrire un programme en R ................................................................................................... 23 Ecrire ses fonctions .............................................................................................................. 24 Les analyses statistiques avec R..................................................................... 25 Les formules......................................................................................................................... 25 Les fonctions gnriques...................................................................................................... 26

Ce document est en grande partie une compilation de R pour les dbutants de Emmanuel Paradis et de Statistiques avec R de Vincent Zoonekynd. (http://zoonek2.free.fr/UNIX/48_R/all.html)

Prambule
R est un systme danalyse statistique et graphique cr par Ross Ihaka et Robert Gentleman. R est la fois un logiciel et un langage qualifi de dialecte du langage S (cr par AT&T Bell Laboratories et disponible sous la forme du logiciel commercialis S-PLUS). R est distribu librement sous les termes de la GNU General Public Licence; son dveloppement et sa distribution sont assurs par plusieurs statisticiens rassembls dans le R Development Core Team. R est disponible sous plusieurs formes : le code crit principalement en C (et certaines routines en Fortran), surtout pour les machines Unix et Linux, ou des excutables prcompils pour Windows, Linux (Debian, Mandrake, RedHat, SuSe), Macintosh et Alpha Unix. Les fichiers pour installer R, partir du code ou des excutables, sont distribus partir du site internet du Comprehensive R Archive Network (CRAN), http://cran.r-project.org/ . R comporte de nombreuses fonctions pour les analyses statistiques et les graphiques ; ceux-ci sont visualiss immdiatement dans une fentre propre et peuvent tre exports sous divers formats (jpg, png, bmp, ps, pdf, emf, pictex, xfig). Les rsultats des analyses statistiques sont affichs lcran, certains rsultats partiels (valeurs de P, coefficients de rgression, rsidus,...) peuvent tre sauvs part, exports dans un fichier ou utiliss dans des analyses ultrieures. Le langage R permet, par exemple, de programmer des boucles qui vont analyser successivement diffrents jeux de donnes. Il est aussi possible de combiner dans le mme programme diffrentes fonctions statistiques pour raliser des analyses plus complexes.

Spcificits de R
Pour utiliser R il suffit de lancer lexcutable correspondant pour dmarrer le programme. Lattente des commandes (par dfaut un crochet >) apparat alors indiquant que R est prt excuter les commandes. Sous Windows, certaines commandes peuvent tre excutes par les menus.

Comment a fonctionne
R est un langage orient-objet. R est un langage interprt et pas compil, cest--dire que les commandes tapes au clavier sont directement excutes sans quil soit besoin de construire un programme complet. Ensuite, la syntaxe de R est trs simple et intuitive. Avec R, une fonction, pour tre excute, scrit toujours avec des parenthses, mme si elles ne contiennent rien (par exemple ls()). Si lutilisateur tape le nom de la fonction sans parenthses, R affichera le contenu des instructions de cette fonction. Orient-objet signifie que les variables, les donnes, les fonctions, les rsultats, etc. sont stocks dans la mmoire de lordinateur sous forme dobjets qui ont chacun un nom. Lutilisateur va agir sur ces objets avec des oprateurs (arithmtiques, logiques et de comparaison) et des fonctions (qui sont ellesmmes des objets). Toutes les actions de R sont effectues sur les objets prsents dans la mmoire vive de lordinateur: aucun fichier temporaire nest utilis. Les lectures et critures de fichiers sont utilises pour la lecture et lenregistrement des donnes et des rsultats (graphiques, . . .). Lutilisateur excute des fonctions par lintermdiaire de commandes. Les rsultats sont affichs directement lcran, ou stocks dans un objet, ou encore crits sur le disque. Les rsultats tant eux-mmes des objets, ils peuvent tre

considrs comme des donnes et tre analyss leur tour. Les fichiers de donnes peuvent tre lus sur le disque de lordinateur local ou sur un serveur distant via internet. Les fonctions disponibles sont stockes dans des bibliothques localises sur le disque dans le rpertoire R/library (R dsignant le rpertoire o R est install). Ce rpertoire contient des packages de fonctions, eux-mmes prsents sur le disque sous forme de rpertoires. Le package nomm base est en quelque sorte le cur de R et contient les fonctions de base du langage pour la lecture et la manipulation des donnes, des fonctions graphiques, et certaines fonctions statistiques (modles linaires et analyse de variance utilises en rgression). La commande la plus simple consiste taper le nom dun objet pour afficher son contenu. Par exemple, si un objet n contient la valeur 10 : > n [1] 10 Le chiffre 1 entre crochets indique que laffichage commence au premier lment de n.. Le nom dun objet doit obligatoirement commencer par une lettre (A-Z et a-z) et peut comporter des lettres, des chiffres (0-9), et des points (.). Il faut savoir aussi que R distingue, pour les noms des objets, les majuscules des minuscules.

Crer, lister et effacer les objets en mmoire

Un objet peut tre cr avec loprateur assigner qui scrit avec une flche compose dun signe moins accol un crochet, ce symbole pouvant tre orient dans un sens ou dans lautre : > n <- 15 > n [1] 15 > 5 -> n > n [1] 5 > x <- 1 > X <- 10 > x [1] 1 > X [1] 10 Si lobjet existe dj, sa valeur prcdente est efface. La valeur ainsi donne peut tre le rsultat dune opration et/ou dune fonction : > n <- 10 + 2 > n [1] 12 > n <- 3 + rnorm(1) > n [1] 2.208807 La fonction rnorm(1) gnre une variable alatoire normale de moyenne zro et variance unit. On peut simplement taper une expression sans assigner sa valeur un objet, le rsultat est alors affich lcran mais nest pas stock en mmoire : > (10 + 2) * 5 [1] 60 La fonction ls permet dafficher une liste simple des objets en mmoire, cest--dire que seuls les noms des objets sont affichs. > name <- "Carmen"; n1 <- 10; n2 <- 100; m <- 0.5 > ls() [1] "m" "n1" "n2" "name" Notons lusage du point-virgule pour sparer des commandes distinctes sur la mme ligne. Si lon veut lister uniquement les objets qui contiennent un caractre donn dans leur nom, on utilisera alors loption pattern (qui peut sabrger avec pat) : > ls(pat = "m") [1] "m" "name" Pour restreindre la liste aux objets dont le nom commence par le caractre en question :

> ls(pat = "m") [1] "m" La fonction ls.str() affiche des dtails sur les objets en mmoire : > ls.str() m : num 0.5 n1 : num 10 n2 : num 100 name : chr "Carmen" Pour effacer des objets de la mmoire, on utilise la fonction rm() : rm(x) pour effacer lobjet x, rm(x, y) pour effacer les objets x et y, rm(list=ls()) pour effacer tous les objets en mmoire ; on pourra ensuite utiliser les mmes options cites pour ls() pour effacer slectivement certains objets : rm(list=ls(pat = "m")).

Laide en ligne
Laide en ligne de R est extrmement utile pour lutilisation des fonctions. Laide est disponible directement pour une fonction donne, par exemple : > ?lm affichera, dans R, laide pour la fonction lm() (linear model). La commande help(lm) ou help("lm") aura le mme effet. Cest cette fonction quil faut utiliser pour accder laide avec des caractres non-conventionnels : > ?* Error: syntax error > help("*") Arithmetic package:base R Documentation Arithmetic Operators ... Lappel de laide ouvre une page avec sur la premire ligne des informations gnrales dont le nom du package o se trouvent la (ou les) fonction(s) ou les oprateurs documents. Ensuite vient un titre suivi de paragraphes qui chacun apporte une information bien prcise. Description: brve description. Usage: pour une fonction donne le nom avec tous ses arguments et les ventuelles valeurs par dfaut (options) ; pour un oprateur donne lusage typique. Arguments: pour une fonction dtaille chacun des arguments. Details: description dtaille. Value: le cas chant, le type dobjet retourn par la fonction ou loprateur. See Also: autres rubriques daide proches ou similaires celle documente. Examples: des exemples qui gnralement peuvent tre excuts sans ouvrir laide avec la fonction examples().Il est conseill de les regarder. Par dfaut, la fonction help ne recherche que dans les packages chargs en mmoire. Loption try.all.packages, dont le dfaut est FALSE, permet de chercher dans tous les packages si sa valeur est TRUE : > help("bs") Error in help("bs") : No documentation for bs in specified packages and libraries: you could try help.search("bs") > help("bs", try.all.packages = TRUE)

topic bs is not in any loaded package but can be found in package splines in library E:/logiciels/rw2001/library (ou bien le rpertoire correspondant sur votre machine). On peut ouvrir laide au format html en tapant : > help.start() La fonction apropos trouve les fonctions qui contiennent dans leur nom la chane de caractres passe en argument ; seuls les packages chargs en mmoire sont cherchs : > apropos(help) [1] "help" "help.search" "help.start" [4] "link.html.help"

Les donnes avec R

Les objets
Nous avons vu que R manipule des objets : ceux-ci sont caractriss bien sr par leur nom et leur contenu, mais aussi par des attributs qui vont spcifier le type de donnes reprsent par un objet. Afin de comprendre lutilit de ces attributs, considrons une variable qui prendrait les valeurs 1, 2 ou 3 : une telle variable peut reprsenter une variable entire (par exemple, le nombre dufs dans un nid), ou le codage dune variable catgorique (par exemple, le sexe dans certaines populations de crustacs : mle, femelle ou hermaphrodite). Il est clair que le traitement statistique de cette variable ne sera pas le mme dans les deux cas : avec R, les attributs de lobjet donnent linformation ncessaire. Plus techniquement, et plus gnralement, laction dune fonction sur un objet va dpendre des attributs de celui-ci. Les objets ont deux attributs intrinsques : le mode et la longueur. Le mode est le type des lments dun objet ; il en existe quatre principaux : numrique, caractre, complexe, et logique (FALSE ou TRUE). Dautres modes existent qui ne reprsentent pas des donnes, par exemple fonction ou expression. La longueur est le nombre dlments de lobjet. Pour connatre le mode et la longueur dun objet on peut utiliser, respectivement, les fonctions mode et length : > x <- 1 > mode(x) [1] "numeric" > length(x) [1] 1 > A <- "methodes statistiques"; compar <- TRUE; z <- 1i > mode(A); mode(compar); mode(z) [1] "character" [1] "logical" [1] "complex" Quelque soit le mode, les valeurs manquantes sont reprsentes par NA (not available). R reprsente correctement des valeurs numriques qui ne sont pas finies, telles que avec Inf et -Inf, ou des valeurs qui ne sont pas des nombres avec NaN (not a number). > x <- 5/0 > x [1] Inf > exp(x) [1] Inf > exp(-x) [1] 0 > x - x [1] NaN Une valeur de mode caractre est entre entre des guillemets doubles ". Il est possible dinclure ce caractre dans la valeur sil suit un antislash \ Lensemble des deux caractres \" sera trait de faon spcifique par certaines fonctions telle que cat pour laffichage lcran
_

> cit <- "She said: \"Double quotes can be included in Rs strings.\"" > cit [1] "She said: \"Double quotes can be included in Rs strings.\"" > cat(cit) She said: "Double quotes can be included in Rs strings." Un vecteur est une variable dans le sens gnralement admis. Un facteur est une variable catgorique. Un array est un tableau k dimensions, une matrice tant un cas particulier darray avec k = 2. A noter que les lments dun array ou dune matrice sont tous du mme mode. Un data.frame est un tableau de donnes compos de un ou plusieurs vecteurs et/ou facteurs ayant tous la mme longueur mais pouvant tre de modes diffrents. Un ts est un jeu de donnes de type sries temporelles (time series) et comporte donc des attributs supplmentaires comme la frquence et les dates. Enfin, une liste peut contenir nimporte quel type dobjet, y compris des listes ! Pour un vecteur, le mode et la longueur suffisent pour dcrire les donnes. Pour les autres objets, dautres informations sont ncessaires et celles-ci sont donnes par les attributs dits nonintrinsques. Parmi ces attributs, citons dim qui correspond au nombre de dimensions dun objet. Par exemple, une matrice compose de 2 lignes et 2 colonnes aura pour dim le couple de valeurs [2, 2] ; par contre sa longueur sera de 4.

Lire des donnes dans un fichier

Pour les lectures et critures dans les fichiers, R utilise le rpertoire de travail. Pour connatre ce rpertoire on peut utiliser la commande getwd() (get working directory), et on peut le modifier avec, par exemple, setwd("C:/data"). Il est ncessaire de prciser le chemin daccs au fichier sil nest pas dans le rpertoire de travail. R peut lire des donnes stockes dans des fichiers texte (ASCII) laide des fonctions suivantes : read.table, scan et read.fwf. R peut galement lire des fichiers dans dautres formats (Excel, SAS, SPSS, . . .) et accder des bases de donnes de type SQL. La fonction read.table a pour effet de crer un data.frame et est donc le moyen principal pour lire des tableaux de donnes. Par exemple, si on a un fichier nomm data.dat, la commande : > mydata <- read.table("data.dat") crera un data.frame nomm mydata, et chaque variable sera nomme, par dfaut, V1, V2, . . . et pourront tre accdes individuellement par mydata$V1, mydata$V2, . . ., ou par mydata ["V1"], mydata["V2"], . . ., ou encore par mydata[, 1], mydata[, 2], . . . Il y a plusieurs options dont voici les valeurs par dfaut (cest--dire celles utilises par R si elles sont omises par lutilisateur) et les dtails dans le tableau qui suit : read.table(file, header = FALSE, sep = "", quote = "\"", dec = ".", row.names, col.names, as.is = FALSE, na.strings = "NA", colClasses = NA, nrows = -1, skip = 0, check.names = TRUE, fill = !blank.lines.skip, strip.white = FALSE, blank.lines.skip = TRUE, comment.char = "#") La fonction scan est plus flexible que read.table. Une diffrence est quil est possible de spcifier le mode des variables, par exemple : > mydata <- scan("data.dat", what = list("", 0, 0)) lira dans le fichier data.dat trois variables, la premire de mode caractre et les deux suivantes de mode numrique. Une autre distinction importante est que scan() peut tre utilise pour crer diffrents objets, vecteurs, matrices, data.frame, listes, . . . Dans lexemple ci-dessus, mydata est une liste de trois vecteurs. Par dfaut, cest--dire si what est omis, scan() cre un vecteur numrique. Si les donnes lues ne correspondent pas au(x) mode(s) attendu(s) (par dfaut ou spcifis par what), un message derreur est retourn. Les options sont les suivantes.

scan(file = "", what = double(0), nmax = -1, n = -1, sep = "", quote = if (sep=="\n") "" else "\"", dec = ".", skip = 0, nlines = 0, na.strings = "NA", flush = FALSE, fill = FALSE, strip.white = FALSE, quiet = FALSE, blank.lines.skip = TRUE, multi.line = TRUE, comment.char = "#") La fonction read.fwf sert lire dans un fichier o les donnes sont dans un format largeur fixe (fixed width format) : read.fwf(file, widths, sep="\t", as.is = FALSE, skip = 0, row.names, col.names, n = -1) Les options sont les mmes que pour read.table() sauf widths qui spcifie la largeur des champs.

Enregistrer les donnes

La fonction write.table crit dans un fichier un objet, typiquement un data.frame mais cela peut trs bien tre un autre type dobjet (vecteur, matrice, . . .). Les arguments et options sont : write.table(x, file = " ", append = FALSE, quote = TRUE, sep = " ", eol = "\n", na = "NA", dec = ".", row.names = TRUE, col.names = TRUE, qmethod = c("escape", "double")) Pour crire de faon plus simple un objet dans un fichier, on peut utiliser la commande write(x, file="data.txt") o x est le nom de lobjet (qui peut tre un vecteur, une matrice ou un array). Il y a deux options : nc (ou ncol) qui dfinit le nombre de colonnes dans le fichier (par dfaut nc=1 si x est de mode caractre, nc=5 pour les autres modes), et append (un logique) pour ajouter les donnes sans effacer celles ventuellement dj existantes dans le fichier (TRUE) ou les effacer si le fichier existe dj (FALSE, le dfaut). Pour enregistrer des objets, on utilisera la commande save (x, y, z, file="xyz.RData"). Pour faciliter lchange de fichiers entre machines et systmes dexploitation, on peut utiliser loption ascii=TRUE. Les donnes (qui sont alors nommes workspace dans le jargon de R) peuvent ultrieurement tre charges en mmoire avec load("xyz.RData"). La fonction save.image est un raccourci pour save(list=ls (all=TRUE), file=".RData").
_

Gnrer des donnes

Squences rgulires
Une squence rgulire de nombres entiers, par exemple de 1 30, peut tre gnre par : > x <- 1:30 On a ainsi un vecteur x avec 30 lments. Cet oprateur : est prioritaire sur les oprations arithmtiques au sein dune expression : > 1:10-1 [1] 0 1 2 3 4 5 6 7 8 9 > 1:(10-1) [1] 1 2 3 4 5 6 7 8 9 La fonction seq peut gnrer des squences de nombres rels de la manire suivante : > seq(1, 5, 0.5) [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 o le premier nombre indique le dbut de la squence, le second la fin, et le troisime lincrment utilis dans la progression de la squence. On peut aussi utiliser : > seq(length=9, from=1, to=5) [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 On peut aussi taper directement les valeurs dsires en utilisant la fonction c (ATTENTION, c est une des fonctions les plus importantes de R): > c(1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5)

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 Il est aussi possible si lon veut taper des donnes au clavier dutiliser la fonction scan avec tout simplement les options par dfaut : > z <- scan() 1: 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 10: Read 9 items > z [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 La fonction rep cre un vecteur qui aura tous ses lments identiques : > rep(1, 30) [1] 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 La fonction sequence va crer une suite de squences de nombres entiers qui chacune se termine par les nombres donns comme arguments cette fonction : > sequence(4:5) [1] 1 2 3 4 1 2 3 4 5 > sequence(c(10,5)) [1] 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 La fonction gl (generate levels) est trs utile car elle gnre des sries rgulires dans un facteur. Cette fonction sutilise ainsi gl(k, n) o k est le nombre de niveaux (ou classes) du facteur, et n est le nombre de rplications pour chaque niveau. Deux options peuvent tre utilises : length pour spcifier le nombre de donnes produites, et labels pour indiquer les noms des niveaux du facteur. Exemples : > gl(3, 5) [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 Levels: 1 2 3 > gl(3, 5, length=30) [1] 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 Levels: 1 2 3 > gl(2, 6, label=c("Male", "Female")) [1] Male Male Male Male Male Male [7] Female Female Female Female Female Female Levels: Male Female > gl(2, 10) [1] 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 Levels: 1 2 > gl(2, 1, length=20) [1] 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 Levels: 1 2 > gl(2, 2, length=20) [1] 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2 Levels: 1 2 Enfin, expand.grid() sert crer un data.frame avec toutes les combinaisons des vecteurs ou facteurs donns comme arguments : > expand.grid(h=c(60,80), w=c(100, 300), sex=c("Male", "Female")) h w sex 1 60 100 Male 2 80 100 Male 3 60 300 Male 4 80 300 Male 5 60 100 Female 6 80 100 Female 7 60 300 Female 8 80 300 Female

Squences alatoires
Il est utile en statistique de pouvoir gnrer des donnes alatoires, et R peut le faire pour un grand nombre de fonctions de densit de probabilit. Ces fonctions sont de la forme rfunc(n, p1, p2,

...), o func indique la loi de probabilit, n le nombre de donnes gnres et p1, p2, . . . sont les valeurs des paramtres de la loi. Ces fonctions peuvent tre utilises en remplaant la lettre r par d, p ou q pour obtenir, dans lordre, la densit de probabilit (dfunc(x, ...)), la densit de probabilit cumule (pfunc(x, ...)), et la valeur de quantile (qfunc(p, ...), avec 0<p<1).

Manipuler les objets

Cration dobjets
On a vu diffrentes faons de crer des objets en utilisant loprateur assigner; le mode et le type de lobjet ainsi cr sont gnralement dtermins de faon implicite. Il est possible de crer un objet en prcisant de faon explicite son mode, sa longueur, son type, etc. On peut, par exemple, crer un vecteur vide puis modifier successivement ses lments, ce qui est beaucoup plus efficace que de rassembler ces lments avec c(). Il peut tre aussi extrmement pratique de crer des objets partir dautres objets. Vecteur. La fonction vector, qui a deux arguments mode et length, va servir crer un vecteur dont la valeur des lments sera fonction du mode spcifi : 0 si numrique, FALSE si logique, ou "" si caractre. Les fonctions suivantes ont exactement le mme effet et ont pour seul argument la longueur du vecteur cr : numeric(),logical(), et character(). Facteur. Un facteur inclue non seulement les valeurs de la variable catgorique correspondante mais aussi les diffrents niveaux possibles de cette variable (mme ceux qui ne sont pas reprsents dans les donnes). La fonction factor cre un facteur avec les options suivantes : factor(x, levels = sort(unique(x), na.last = TRUE), labels = levels, exclude = NA, ordered = is.ordered(x)) levels spcifie quels sont les niveaux possibles du facteur (par dfaut les valeurs uniques du vecteur x), labels dfinit les noms des niveaux, exclude les valeurs de x ne pas inclure dans les niveaux, et ordered est un argument logique spcifiant si les niveaux du facteur sont ordonns. Rappelons que x est de mode numrique ou caractre. > factor(1:3) [1] 1 2 3 Levels: 1 2 3 > factor(1:3, levels=1:5) [1] 1 2 3 Levels: 1 2 3 4 5 > factor(1:3, labels=c("A", "B", "C")) [1] A B C Levels: A B C > factor(1:5, exclude=4) [1] 1 2 3 NA 5 Levels: 1 2 3 5 Matrice. Une matrice est en fait un vecteur qui possde un argument supplmentaire (dim) qui est luimme un vecteur numrique de longueur 2 et qui dfinit les nombres de lignes (nrow) et de colonnes (ncol) de la matrice. Une matrice peut tre cre avec la fonction matrix : matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL) Loption byrow indique si les valeurs donnes par data doivent remplir successivement les colonnes (le dfaut) ou les lignes (si TRUE). Loption dimnames permet de donner des noms aux lignes et colonnes. > matrix(data=5, nr=2, nc=2) [,1] [,2] [1,] 5 5 [2,] 5 5 > matrix(1:6, 2, 3) [,1] [,2] [,3]

10

[1,] 1 3 5 [2,] 2 4 6 > matrix(1:6, 2, 3, byrow=TRUE) [,1] [,2] [,3] [1,] 1 2 3 [2,] 4 5 6 Une autre faon de crer une matrice est de donner les valeurs voulues lattribut dim dun vecteur (attribut qui est initialement NULL) : > x <- 1:15 > x [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 > dim(x) NULL > dim(x) <- c(5, 3) > x [,1] [,2] [,3] [1,] 1 6 11 [2,] 2 7 12 [3,] 3 8 13 [4,] 4 9 14 [5,] 5 10 15 Data frame. On a vu quun data.frame est cr de faon implicite par la fonction read.table; on peut galement crer un data.frame avec la fonction data.frame. Les vecteurs inclus dans le data.frame doivent tre de mme longueur, ou si un de ces lments est plus court il est alors recycl un nombre entier de fois : > x <- 1:4; n <- 10; M <- c(10, 35); y <- 2:4 > data.frame(x, n) x n 1 1 10 2 2 10 3 3 10 4 4 10 > data.frame(x, M) x M 1 1 10 2 2 35 3 3 10 4 4 35 > data.frame(x, y) Error in data.frame(x, y) : arguments imply differing number of rows: 4, 3 Liste. Une liste est cre de la mme faon quun data.frame avec la fonction list. Il ny a aucune contrainte sur les objets qui y sont inclus. A la diffrence de data.frame(), les noms des objets ne sont pas repris par dfaut ; en reprenant les vecteurs x et y de lexemple prcdant : > L1 <- list(x, y); L2 <- list(A=x, B=y) > L1 [[1]] [1] 1 2 3 4 [[2]] [1] 2 3 4 > L2 $A [1] 1 2 3 4 $B [1] 2 3 4 > names(L1) NULL > names(L2) [1] "A" "B"

11

Srie temporelle. La fonction ts va crer un objet de classe "ts" partir dun vecteur (srie temporelle simple) ou dune matrice (srie temporelle multiple), et des options qui caractrisent la srie. Les options, avec les valeurs par dfaut, sont : ts(data = NA, start = 1, end = numeric(0), frequency = 1, deltat = 1, ts.eps = getOption("ts.eps"), class, names) data un vecteur ou une matrice start le temps de la 1re observation, soit un nombre, ou soit un vecteur de deux entiers end le temps de la dernire observation spcifi de la mme faon que start frequency nombre dobservations par unit de temps deltat la fraction de la priode dchantillonnage entre observations successives (ex. 1/12 pour des donnes mensuelles) ; seulement un de frequency ou deltat doit tre prcis ts.eps tolrance pour la comparaison de sries. Les frquences sont considres gales si leur diffrence est infrieure ts.eps class classe donner lobjet ; le dfaut est "ts" pour une srie simple, et c("mts", "ts") pour une srie multiple names un vecteur de mode caractre avec les noms des sries individuelles dans le cas dune srie multiple ; par dfaut les noms des colonnes de data, ou Series 1, Series 2, . . . > ts(1:10, start = 1959) Time Series: Start = 1959 End = 1968 Frequency = 1 [1] 1 2 3 4 5 6 7 8 9 10 > ts(1:47, frequency = 12, start = c(1959, 2)) > ts(1:10, frequency = 4, start = c(1959, 2)) > ts(matrix(rpois(36, 5), 12, 3), start=c(1961, 1), frequency=12) ( vous de les essayer). Expression. Les objets de mode expression ont un rle fondamental dans R. Une expression est une suite de caractres qui ont un sens pour R. Toutes les commandes valides sont des expressions. Lorsque la commande est tape directement au clavier, elle est alors value par R qui lexcute si elle est valide. Dans bien des circonstances, il est utile de construire une expression sans lvaluer : cest le rle de la fonction expression. On pourra valuer lexpression ultrieurement avec eval(). > x <- 3; y <- 2.5; z <- 1 > exp1 <- expression(x / (y + exp(z))) > exp1 expression(x/(y + exp(z))) > eval(exp1) [1] 0.5749019 Certaines fonctions utilisent des expressions en tant quargument, par exemple D() qui calcule des drives partielles : > D(exp1, "x") 1/(y + exp(z)) > D(exp1, "y") -x/(y + exp(z))2 > D(exp1, "z") -x * exp(z)/(y + exp(z))2

Les oprateurs
Les oprateurs arithmtiques : +, -, *, /, ^, %% (modulo), % / % (division entire) Les oprateurs de comparaison : <, >, <=, >=, == (gal), != (diffrent) Les oprateurs logiques : ! x (NON logique), x & y (ET), x && y (idem), x | y (OU logique), x || y (idem), xor(x, y) (OU exclusif)

12

Les oprateurs arithmtiques agissent sur les variables de mode numrique ou complexe, mais aussi sur celles de mode logique ; dans ce dernier cas, les valeurs logiques sont converties en valeurs numriques. Les oprateurs de comparaison peuvent sappliquer nimporte quel mode : ils retournent une ou plusieurs valeurs logiques. Les oprateurs logiques sappliquent un (!) ou deux objets de mode logique et retournent une (ou plusieurs) valeurs logiques. Les oprateurs ET et OU existent sous deux formes : la forme simple opre sur chaque lment des objets et retourne autant de valeurs logiques que de comparaisons effectues ; la forme double opre sur le premier lment des objets. On utilisera loprateur ET pour spcifier une ingalit du type 0 < x < 1 qui sera code ainsi : 0 < x & x < 1. Lexpression 0 < x < 1 est valide mais ne donnera pas le rsultat escompt : les deux oprateurs de cette expression tant identiques, ils seront excuts successivement de la gauche vers la droite. Lopration 0 < x sera dabord ralise retournant une valeur logique qui sera ensuite compare 1 (TRUE ou FALSE < 1) : dans ce cas la valeur logique sera convertie implicitement en numrique (1 ou 0 < 1). Les oprateurs de comparaison oprent sur chaque lment des deux objets qui sont compars (en recyclant ventuellement les valeurs si lun est plus court), et retournent donc un objet de mme taille. Pour effectuer une comparaison globale de deux objets, il faut utiliser la fonction identical : > x <- 1:3; y <- 1:3 > x == y [1] TRUE TRUE TRUE > identical(x, y) [1] TRUE

Accder aux valeurs dun objet : le systme dindexation

Lindexation est un moyen efficace et flexible daccder de faon slective aux lments dun objet ; elle peut tre numrique ou logique. Pour accder , par exemple, la 3me valeur dun vecteur x, on tape x[3]. Si x est une matrice ou un data.frame, on accdera la valeur de la i me ligne et jme colonne par x[i, j]. Pour changer toutes les valeurs de la 3me colonne, on peut taper : > x[, 3] <- 10.2 Ce systme dindexation se gnralise facilement pour les array, on aura alors autant dindices que larray a de dimensions (par exemple pour une array trois dimensions : x[i, j, k], x[, , 3], . . .). Il faut retenir que lindexation se fait laide de crochets (attention, la diffrence de Matlab o lindexation se fait avec des parenthses) les parenthses tant rserves pour les arguments dune fonction : > x(1) Error: couldnt find function "x" Lindexation peut aussi tre utilise pour supprimer une (des) ligne(s) ou colonne(s). Par exemple, x[-1, ] supprimera la 1re ligne, ou x[-c(1, 15), ] fera de mme avec les 1re et 15me lignes. Pour les vecteurs, matrices et array il est possible daccder aux valeurs de ces lments laide dune expression de comparaison en guise dindice : > x <- 1:10 > x[x >= 5] <- 20 > x [1] 1 2 3 4 20 20 20 20 20 20 > x[x == 1] <- 25 > x [1] 25 2 3 4 20 20 20 20 20 20 Une utilisation pratique de cette indexation logique est, par exemple, la possibilit de slectionner les lments pairs dune variable entire : > x <- rpois(40, lambda=5) > x [1] 5 9 4 7 7 6 4 5 11 3 5 7 1 5 3 9 2 2 5 2 [21] 4 6 6 5 4 5 3 4 3 3 3 7 7 3 8 1 4 2 1 4

13

> x[x %% 2 == 0] [1] 4 6 4 2 2 2 4 6 6 4 4 8 4 2 4 Ce systme dindexation utilise donc des valeurs logiques retournes dans ce cas par les oprateurs de comparaison. Ces valeurs logiques peuvent tre calcules au pralable, elles seront ventuellement recycles : > x <- 1:40 > s <- c(FALSE, TRUE) > x[s] [1] 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 Lindexation logique peut galement tre utilise avec des data.frames, mais avec la difficult que les diffrentes colonnes du data.frame peuvent tre de modes diffrents. Pour les listes, laccs aux diffrents lments (qui peuvent tre nimporte quel objet) se fait avec des crochets doubles, par exemple my.list[[3]] pour accder au 3me objet de la liste nomme my.list. Le rsultat pourra ensuite tre index de la mme faon que lon a vu prcdemment pour les vecteurs, matrices, etc. Si ce 3me objet en question est un vecteur, ses valeurs pourront tre modifies avec my.list[[3]][i], sil sagit dun array trois dimensions avec my.list[[3]][i, j, k], etc.

Accder aux valeurs dun objet avec les noms

Les noms sont des attributs dont il existe plusieurs sortes (names, colnames, rownames, dimnames). Si les lments dun objet ont des noms, ils peuvent tre extraits en les utilisant en guise dindices. De cette faon les attributs de lobjet dorigine sont conservs. Par exemple, si un data.frame DF comporte les variables x, y, et z, la commande DF["x"] donnera un data.frame avec juste x ; DF[c("x", "y")] donnera un data.frame avec les deux variables correspondantes. Ce systme marche aussi avec une liste si ses lments ont des noms. Pour extraire un vecteur ou un facteur dun data.frame on utilisera le symbole $ (par ex. DF$x). Cette procdure marche galement avec les listes.

Calcul arithmtique et fonctions simples

Il existe de nombreuses fonctions dans R pour manipuler les donnes. La plus simple, on la vue plus haut, est c qui concatne les objets numrs entre parenthses. Par exemple : > c(1:5, seq(10, 11, 0.2)) [1] 1.0 2.0 3.0 4.0 5.0 10.0 10.2 10.4 10.6 10.8 11.0 Les vecteurs peuvent tre manipuls selon des expressions arithmtiques classiques : > x <- 1:4 > y <- rep(1, 4) > z <- x + y > z [1] 2 3 4 5 Des vecteurs de longueurs diffrentes peuvent tre additionns, dans ce cas le vecteur le plus court est recycl. Exemples : > x <- 1:4 > y <- 1:2 > z <- x + y > z [1] 2 4 4 6 > x <- 1:3 > y <- 1:2 > z <- x + y Warning message: longer object length is not a multiple of shorter object length in: x + y > z [1] 2 4 4

14

On notera que R a retourn un message davertissement et non pas un message derreur, lopration a donc t effectue. Si lon veut ajouter (ou multiplier) la mme valeur tous les lments dun vecteur > x <- 1:4 > a <- 10 > z <- a * x > z [1] 10 20 30 40 Les fonctions disponibles avec R sont trop nombreuses pour tre numres ici. On trouve toutes les fonctions mathmatiques de base (log, exp, log10, log2, sin, cos, tan, asin, acos, atan, abs, sqrt, . . .), des fonctions spciales (gamma, digamma, beta, besselI, . . .), ainsi que diverses fonctions utiles en statistiques. Essayez les fonctions suivantes :
sum(x), prod(x), max(x), min(x), which.max(x), which.min(x), range(x), length(x), mean(x), median(x), var(x), cov(x), cor(x), var(x,y), cov(x,y), cor(x,y), round(x,n), rev(x), sort(x), rank(x), log(x, base), scale(x), pmin(x,y,), pmax(x,y,), cumsum(x), cumprod(x), cumin(x), cummax(x), match(x,y), which(x == a), choose(n,k), na.omit(x), na.fail(x), unique(x), table(), subset(x, ) sample(x, size).

Calcul matriciel
R offre des facilits pour le calcul et la manipulation de matrices. Les fonctions rbind() et cbind() juxtaposent des matrices en conservant les lignes ou les colonnes, respectivement : > m1 <- matrix(1, nr = 2, nc = 2) > m2 <- matrix(2, nr = 2, nc = 2) > rbind(m1, m2) [,1] [,2] [1,] 1 1 [2,] 1 1 [3,] 2 2 [4,] 2 2 > cbind(m1, m2) [,1] [,2] [,3] [,4] [1,] 1 1 2 2 [2,] 1 1 2 2 Loprateur pour le produit de deux matrices est %*%. Par exemple, en reprenant les deux matrices m1 et m2 ci-dessus : > rbind(m1, m2) %*% cbind(m1, m2) [,1] [,2] [,3] [,4] [1,] 2 2 4 4 [2,] 2 2 4 4 [3,] 4 4 8 8 [4,] 4 4 8 8 > cbind(m1, m2) %*% rbind(m1, m2) [,1] [,2] [1,] 10 10 [2,] 10 10 La transposition dune matrice se fait avec la fonction t ; cette fonction marche aussi avec un data.frame. La fonction diag sert extraire, modifier la diagonale dune matrice, ou encore construire une matrice diagonale. Taper dans votre fentre R les commandes suivantes : > diag(m1) > diag(rbind(m1, m2) %*% cbind(m1, m2)) > diag(m1) <- 10 > m1 > diag(3) > v <- c(10, 20, 30) > diag(v) > diag(2.1, nr = 3, nc = 5)

15

R a galement des fonctions spciales pour le calcul matriciel comme par exemple solve() pour linversion dune matrice, qr() pour la dcomposition, eigen() pour le calcul des valeurs et vecteurs propres, et svd() pour la dcomposition en valeurs singulires. Essayez-les !

Les graphiques avec R

R offre une varit de graphiques remarquable. Pour avoir une petite ide des possibilits offertes, il suffit de taper la commande demo(graphics). Le rsultat dune fonction graphique est envoy un dispositif graphique (graphical device) (i.e. une fentre graphique ou un fichier). Il existe deux sortes de fonctions graphiques : principales qui crent un nouveau graphe, et secondaires qui ajoutent des lments un graphe dj existant. Les graphes sont produits en fonction de paramtres graphiques qui sont dfinis par dfaut et peuvent tre modifis avec la fonction par.

Gestion des graphiques

Ouvrir plusieurs dispositifs graphiques
Lorsquune fonction graphique est excute, si aucun dispositif graphique nest alors ouvert, R ouvrira une fentre graphique et y affichera le graphe. Un dispositif graphique peut tre ouvert avec une fonction approprie. Un dispositif graphique de type fichier sera ouvert avec une fonction qui dpend du format : postscript(), pdf(), png(), . . . Pour connatre la liste des dispositifs disponibles pour votre installation, tapez ?device. Le dernier dispositif ouvert devient le dispositif graphique actif sur lequel seront affichs les graphes suivants. La fonction dev.list() affiche la liste des dispositifs ouverts : Les chiffres qui saffichent correspondent aux numros des dispositifs qui doivent tre utiliss si lon veut changer le dispositif actif. Pour connatre le dispositif actif dev.cur() et pour changer le dispositif actif dev.set(). La fonction dev.off() ferme un dispositif graphique.

Partitionner un graphique
La fonction split.screen partitionne le graphique actif. Par exemple : > split.screen(c(1, 2)) va diviser le graphique en deux parties quon slectionnera avec screen(1) ou screen(2); erase.screen() efface le graphe dernirement dessin. Une partie peut tre elle-mme divise avec split.screen() donnant la possibilit de faire des arrangements complexes. Ces fonctions sont incompatibles avec dautres (tel layout() ou coplot()). La fonction layout partitionne le graphique actif en plusieurs parties sur lesquelles sont affichs les graphes successivement. Cette fonction a pour argument principal une matrice avec des valeurs entires qui indiquent les numros des sous-fentres. Par exemple, si lon veut diviser la fentre en quatre parties gales : > mat <- matrix(1:4, 2, 2) > mat [,1] [,2] [1,] 1 3 [2,] 2 4 > layout(mat) > layout.show(4) Pour visualiser la partition cre on a utilis la fonction layout.show avec en argument le nombre de sous-fentres. Ainsi, beaucoup de possibilits sont offertes et vous pouvez les explorer.

16

Les fonctions graphiques

Voici un aperu des fonctions graphiques de R.
plot(x) graphe des valeurs de x (sur laxe des y) ordonnes sur laxe des x plot(x, y) graphe bivari de x (sur laxe des x) et y (sur laxe des y) sunflowerplot(x,y) idem que plot() mais les points superposs sont dessins sous forme de fleurs dont le nombre de ptales reprsente le nombre de points piechart(x) graphe en camembert boxplot(x) graphe boites et moustaches stripplot(x) graphe des valeurs de x sur une ligne (une alternative boxplot() pour des petits chantillons) coplot(x~y|z) graphe bivari de x et y pour chaque valeur ou intervalle de valeurs de z interaction.plot(f1, f2, y) si f1 et f2 sont des facteurs, graphe des moyennes de y (sur laxe des y) en fonction des valeurs de f1 (sur laxe des x) et de f2 (diffrentes courbes) ; loption fun permet de choisir la statistique rsume de y (par dfaut fun=mean) matplot(x,y) graphe bivari de la 1re colonne de x contre la 1re de y, la 2me de x contre la 2me de y, etc. pairs(x) si x est une matrice ou un data.frame, dessine tous les graphes bivaris entre les colonnes de x plot.ts(x) si x est un objet de classe "ts", graphe de x en fonction du temps, x peut tre multivari mais les sries doivent avoir les mmes frquence et dates ts.plot(x) idem mais si x est multivari les sries peuvent avoir des dates diffrentes et doivent avoir la mme frquence hist(x) histogramme des frquences de x barplot(x) histogramme des valeurs de x qqnorm(x) quantiles de x en fonction des valeurs attendues selon une loi normale qqplot(x, y) quantiles de y en fonction des quantiles de x contour(x, y, z) courbes de niveau (les donnes sont interpoles pour tracer les courbes), x et y doivent tre des vecteurs et z une matrice telle que dim(z)=c(length(x),length(y)) (x et y peuvent tre omis) filled.contour(x, y, z) idem mais les aires entre les contours sont colores, et une lgende des couleurs est galement dessine image(x, y, z) idem mais en couleur (les donnes sont traces) persp(x, y, z) idem mais en 3-D (les donnes sont traces) stars(x) si x est une matrice ou un data.frame, dessine un graphe en segments ou en toile o chaque ligne de x est reprsente par une toile et les colonnes par les longueurs des branches symbols(x, y,...) dessine aux coordonnes donnes par x et y des symboles (cercles, carrs, rectangles, toiles, thermomtres ou boxplots) dont les tailles, couleurs . . . sont spcifies par des arguments supplmentaires termplot(mod.obj) graphe des effets (partiels) dun modle de rgression (mod.obj) dotplot(x) si x est un data.frame, dessine un graphe de Cleveland (graphes superposs ligne par ligne et colonne par colonne) visualise, avec des quarts de cercles, lassociation entre deux variables dichotomiques pour fourfoldplot(x) diffrentes populations (x doit tre un array avec dim=c(2, 2, k) ou une matrice avec dim=c(2, 2) si k=1) assocplot(x) graphe de CohenFriendly indiquant les dviations de lhypothse dindpendance des lignes et des colonnes dans un tableau de contingence deux dimensions mosaicplot(x) graphe en mosaque des rsidus dune rgression log-linaire sur une table de contingence

Il est peu prs vident que pour une premire prise de contact avec R vous nutiliserez pas toutes ces fonctions, mais il est peut-tre utile davoir une liste. Pour chaque fonction, les options peuvent tre trouves via laide en ligne de R. Certaines de ces options sont identiques pour plusieurs fonctions graphiques ; voici les principales (avec leurs ventuelles valeurs par dfaut) : add=FALSE si TRUE superpose le graphe au graphe existant (sil y en a un) axes=TRUE si FALSE ne trace pas les axes ni le cadre type="p" le type de graphe qui sera dessin, "p" : points, "l": lignes, "b" :points connects par des lignes, "o" : idem mais les lignes recouvrent les points, "h" : lignes verticales, "s" : escaliers, les donnes tant reprsentes par le sommet des lignes verticales, "S" : idem mais les donnes tant reprsentes par le bas des lignes verticales

17

xlim=, ylim= xlab=, ylab= main= sub=

fixe les limites infrieures et suprieures des axes, par exemple avec xlim=c(1, 10) ou xlim=range(x) annotations des axes, doivent tre des variables de mode caractre titre principal, doit tre une variable de mode caractre sous-titre (crit dans une police plus petite)

Il y a dans R un ensemble de fonctions graphiques qui ont une action sur un graphe dj existant (ces fonctions sont appeles low-level plotting commands dans le jargon de R, alors que les fonctions prcdentes sont nommes high-level plotting commands). Nous ne donneront pas la liste ici.
_

En plus des fonctions graphiques secondaires, la prsentation des graphiques peut tre amliore grce aux paramtres graphiques. Ceux-ci sutilisent soit comme des options des fonctions graphiques principales ou secondaires (mais cela ne marche pas pour tous), soit laide de la fonction par qui permet denregistrer les changements des paramtres graphiques de faon permanente, cest--dire que les graphes suivants seront dessins en fonction des nouveaux paramtres spcifis par lutilisateur. Par exemple, linstruction suivante : > par(bg="yellow") fera que tous les graphes seront dessins avec un fond jaune. Il y a 68 paramtres graphiques, dont certains ont des rles proches. La liste dtaille peut tre obtenue avec ?par.

Un exemple concret
Afin dillustrer lutilisation des fonctionnalits graphiques de R, considrons un cas concret et simple dun graphe bivari de 10 paires de valeurs alatoires. Ces valeurs ont t gnres avec : > x <- rnorm(10) > y <- rnorm(10) Le graphe voulu sera obtenu avec plot(); on tapera la commande : > plot(x, y) et le graphique sera dessin sur le graphique actif. Par dfaut, R dessine les graphiques de faon intelligente : lespacement entre les graduations sur les axes, la disposition des annotations, etc. sont calculs afin que le graphique obtenu soit le plus intelligible possible. Lutilisateur peut toutefois vouloir changer lallure du graphe. La faon la plus simple de changer la prsentation dun graphe est dajouter des options qui modifieront les arguments par dfaut. Dans notre cas, on peut modifier de faon apprciable notre figure de la faon suivante : plot(x, y, xlab="Ten random values", ylab="Ten other values", xlim=c(-2, 2), ylim=c(-2, 2), pch=22, col="red", bg="yellow", bty="l", tcl=0.4, main="How to customize a plot with R", las=1, cex=1.5) Voyons en dtail chacune des options utilise. Dabord xlab et ylab vont changer les annotations sur les axes qui, par dfaut, taient les noms des variables. Ensuite, xlim et ylim nous permettent de dfinir les limites sur les deux axes. Le paramtre graphique pch a t ici utilis comme option : pch=22 spcifie un carr dont la couleur du contour et celle de lintrieur peuvent tre diffrentes et qui sont donnes, respectivement, par col et bg. En utilisant laide en ligne vous pouvez comprendre leffet des paramtres bty, tcl, las et cex. Enfin, un titre a t ajout par loption main. Un peu plus compliqu : Les paramtres graphiques et les fonctions graphiques secondaires permettent daller plus loin dans la prsentation dun graphe. Certains paramtres graphiques ne peuvent pas tre passs comme arguments dans une fonction comme plot. On va maintenant modifier certains de ces paramtres avec par(), il est donc ncessaire cette fois de taper plusieurs commandes. Quand on change les paramtres graphiques, il est utile de sauver les valeurs initiales de ces paramtres au pralable afin de pouvoir les rtablir par la suite. opar <- par() par(bg="lightyellow", col.axis="blue", mar=c(4, 4, 2.5, 0.25))

18

plot(x, y, xlab="Ten random values", ylab="Ten other values", xlim=c(-2, 2), ylim=c(-2, 2), pch=22, col="red", bg="yellow", bty="l", tcl=-.25, las=1, cex=1.5) title("How to customize a plot with R (bis)", font.main=3, adj=1) par(opar) Dtails des actions provoques par ces commandes. Tout dabord, les paramtres graphiques par dfaut sont sauvs dans une liste qui est nomme opar. Trois paramtres vont tre modifis ensuite : bg pour la couleur de larrire plan, col.axis pour la couleur des chiffres sur les axes et mar pour les dimensions des marges. Enfin, les paramtres graphiques initiaux sont restaurs avec la dernire commande. Pour mettre plusieurs courbes sur la mme figure, vous pouvez procder comme dans lexemple qui suit : > N <- 200 > x <- seq(-4,4, length=N) > y1 <- sin(x) > y2 <- cos(x) > plot(x, y1, col="blue", type="l",xlab="",ylab="") > par(new=TRUE) > plot(x, y2, col="red", type="l",xlab="",ylab="") > legend("bottom",c("sin","cos"),lty=1:2) Pour positionner la lgende un autre endroit, utiliser les mots-cls bottomright, bottom, bottomleft, left, topleft, top, topright, right, center ; pour connatre toutes les possibilits de legend, taper help(legend).

On peut bien sr faire encore plus compliqu que a, mais pour linstant on sarrte l.

Les packages grid et lattice

Les packages grid et lattice reprsentent limplmentation dans R des graphiques de type Trellis de SPLUS. Trellis est une approche pour la visualisation de donnes multivaries particulirement approprie pour lexploration de relations ou dinteractions entre variables. Lide principale derrire lattice est celle des graphes multiples conditionns : un graphe bivari entre deux variables sera dcoup en plusieurs graphes en fonction des valeurs dune troisime variable. La fonction coplot utilise une approche similaire, mais lattice offre des fonctionnalits plus vastes que cette fonction. Les graphes produits par lattice ou grid ne peuvent pas tre combins ou mlangs avec ceux produits par les fonctions graphiques vues prcdemment, car ces packages utilisent un nouveau mode graphique. La plupart des fonctions de lattice prennent pour argument principal une formule, par exemple y~x. La formule y~x|z signifie que le graphe de y en fonction de x sera dessin en plusieurs sousgraphes en fonction des valeurs de z. Ci-dessous les principales fonctions de lattice. La formule donne en argument est la formule type ncessaire, mais toutes ces fonctions acceptent une formule conditionnelle (y~x|z) comme argument principal ; dans ce cas un graphe multiple, en fonction des valeurs de z, est dessin.
histogramme des valeurs de y en fonction de celles de x graphe boites et moustaches graphe de fonctions de densit graphe de Cleveland (graphes superposs ligne par ligne et colonne par colonne) histogrammes des frquences de x quantiles de x en fonction des valeurs attendues selon une distribution thorique graphe unidimensionnel, x doit tre numrique, y peut tre un facteur quantiles pour comparer deux distributions, x doit tre numrique, y peut tre numrique, caractre ou facteur mais doit avoir deux niveaux xyplot(y ~ x) graphes bivaris (avec de nombreuses fonctionnalits) levelplot(z ~ x*y) graphe en couleur des valeurs de z aux coordonnes fournies par x et y (x, y et z sont tous de mme longueur) splom(~ x) matrice de graphes bivaris barchart(y ~ x) bwplot(y ~ x) densityplot(~ x) dotplot(y ~ x) histogram(~ x) qqmath(~ x) stripplot(y ~ x) qq(y ~ x)

19

parallel(~ x)

graphe de coordonnes parallles

Certaines fonctions de lattice ont le mme nom que des fonctions graphiques du package base. Ces dernires sont masqus lorsque lattice est charg en mmoire. Exemples : Il faut au pralable charger le package en mmoire avec la commande library(lattice)afin daccder aux fonctions. Dabord, les graphes de fonctions de densit. Un tel graphe peut tre dessin simplement avec densityplot(~ x) qui tracera une courbe de densit empirique ainsi que les points correspondants aux observations sur laxe des x (comme rug()). Notre exemple sera un peu plus compliqu avec la superposition, sur chaque graphe, des courbes de densit empirique et de densit estime avec une loi normale. Il nous faut cette fin utiliser largument panel qui dfinit ce qui doit tre trac dans chaque graphe. Les commandes sont : n <- seq(5, 45, 5) x <- rnorm(sum(n)) y <- factor(rep(n, n), labels=paste("n =", n)) densityplot(~ x | y, panel = function(x, ...) { panel.densityplot(x, col="DarkOliveGreen", ...) panel.mathdensity(dmath=dnorm, args=list(mean=mean(x), sd=sd(x)), col="darkblue") }) Les trois premires lignes gnrent un chantillon de variables normales que lon divise en souschantillons deffectif gal 5, 10, 15, . . . et 45. Ensuite vient lappel de densityplot() qui produit un graphe par sous-chantillon. panel prend pour argument une fonction. Dans notre exemple, nous avons dfini une fonction qui fait appel deux fonctions prdfinies dans lattice : panel.densityplot qui trace la fonction de densit empirique et panel.mathdensity qui trace la fonction de densit estime avec une loi normale. La fonction panel.densityplot est appelle par dfaut si aucun argument nest donn panel. Lexemple suivant utilise des donnes disponibles dans R : les localisations de 1000 sismes prs des les Fidji. data(quakes) mini <- min(quakes$depth) maxi <- max(quakes$depth) int <- ceiling((maxi - mini)/9) inf <- seq(mini, maxi, int) quakes$depth.cat <- factor(floor(((quakes$depth - mini) / int)), labels=paste(inf, inf + int, sep="-")) xyplot(lat ~ long | depth.cat, data = quakes) La premire commande charge le jeu de donnes quakes en mmoire. Les cinq commandes suivantes crent un facteur en divisant la profondeur (variable depth) en neuf intervalles dtendues gales : les niveaux de ce facteur sont nomms avec les bornes infrieures et suprieures de ces intervalles. Il suffit ensuite dappeller la fonction xyplot avec la formule approprie et un argument data qui indique o xyplot doit chercher les variables Un autre exemple clbre est celui des donnes biomtriques sur des fleurs de trois espces diris (data(iris) pour les charger). On ne le prsente pas ici, mais vous trouverez facilement comment faire avec laide en ligne. Pour connatre la liste de toutes les donnes disponibles dans le package datasets, taper data(). Pour connatre la liste des donnes dans tous les packages taper data(package = .packages(all.available = TRUE)).

20

Les packages
Liste des packages distribus avec le package base. ctest tests classiques (Fisher, Student, Wilcoxon, Pearson, Bartlett, Kolmogorov-Smirnov) eda mthodes dcrites dans Exploratory Data Analysis de Tukey (seulement ajustement robuste et lissage) lqs rgression rsistante et estimation de covariance methods dfinition des mthodes et classes pour les objets R ainsi que des utilitaires pour la programmation modreg rgression moderne (lissage et ajustement local) mva analyses multivaries nls rgression non-linaire splines reprsentations polynomiales stepfun analyse de fonctions de distributions empiriques tcltk fonctions pour utiliser les lments de linterface graphique de Tcl/Tk tools utilitaires pour le dveloppement de package et ladministration ts analyse de sries temporelles A lexception de ctest qui est charg au dmarrage de R, chaque package est utilisable aprs lavoir charg en mmoire : > library(eda) La liste des fonctions dun package peut tre affiche avec : > library(help=eda) De nombreux packages contribus allongent la liste des analyses possibles avec R. Ils sont distribus sparment, et doivent tre installs et chargs en mmoire sous R. Une liste complte de ces packages contribus, accompagne dune description, se trouve sur le site Web du CRAN http://cran.r-project.org/ . Certains de ces packages sont regroups parmi les packages recommands car ils couvrent des mthodes souvent utilises en analyse des donnes. boot mthodes de r-chantillonnage et de bootstrap class mthodes de classification cluster mthodes daggrgation foreign fonctions pour importer des donnes enregistrs sous divers formats (S3, Stata, SAS, Minitab, SPSS, Epi Info) KernSmooth mthodes pour le calcul de fonctions de densit (y compris bivaries) MASS contient de nombreuses fonctions, utilitaires et jeux de donnes accompagnant le livre Modern Applied Statistics with S-PLUS par Venables & Ripley mgcv modles additifs gnraliss nlme modles linaires ou non-linaires effets mixtes nnet rseaux neuroniques et modles log-linaires multinomiaux rpart mthodes de partitionnement rcursif spatial analyses spatiales (kriging, covariance spatiale, . . .) survival analyses de survie

21

Programmer avec R
Boucles et vectorisation
Comme les autres langages, R possde des structures de contrle. Supposons quon a un vecteur x, et pour les lments de x qui ont la valeur b, on va donner la valeur 0 une autre variable y, sinon 1. On cre dabord un vecteur y de mme longueur que x : y <- numeric(length(x)) for (i in 1:length(x)) if (x[i] == b) y[i] <- 0 else y[i] <- 1 On peut faire excuter plusieurs instructions si elles sont encadres dans des accolades : for (i in 1:length(x)) { y[i] <- 0 ... } if (x[i] == b) { y[i] <- 0 ... } Une autre situation possible est de vouloir faire excuter une instruction tant quune condition est vraie: while (myfun > minimum) { ... } Les boucles et structures de contrle peuvent cependant tre vites dans la plupart des situations et ce grce la vectorisation. La structure vectorielle rend les boucles implicites dans les expressions. Considrons laddition de deux vecteurs : > z <- x + y Cette addition pourrait tre crite avec une boucle comme cela se fait dans la plupart de langages : > z <- numeric(length(x)) > for (i in 1:length(z)) z[i] <- x[i] + y[i] Dans ce cas il est ncessaire de crer le vecteur z au pralable cause de lutilisation de lindexation. On ralise que cette boucle explicite ne fonctionnera que si x et y sont de mme longueur : elle devra tre modifie si cela nest pas le cas, alors que la premire expression marchera quelque soit la situation. Les excutions conditionnelles (if ... else) peuvent tre vites avec lindexation logique ; en reprenant lexemple plus haut : > y[x == b] <- 0 > y[x != b] <- 1 Il y a galement les fonctions du type apply qui vitent dcrire des boucles. apply() agit sur les lignes et/ou les colonnes dune matrice, sa syntaxe est apply(X, MARGIN, FUN, ...), o X est la matrice, MARGIN indique si laction doit tre applique sur les lignes (1), les colonnes (2) ou les deux (c(1, 2)), FUN est la fonction (ou loprateur mais dans ce cas il doit tre spcifi entre guillemets doubles) qui sera utilise, et ... sont dventuels arguments supplmentaires pour FUN. Exemple : > x <- rnorm(10, -5, 0.1) > y <- rnorm(10, 5, 2) > X <- cbind(x, y) # les colonnes de X gardent les noms "x" et "y" > apply(X, 2, mean) > apply(X, 2, sd) lapply() va agir sur une liste : la syntaxe est similaire celle dapply et le rsultat retourn est une liste. > forms <- list(y ~ x, y ~ poly(x, 2))

22

> lapply(forms, lm) sapply() est une variante plus flexible de lapply() qui peut prendre un vecteur ou une matrice en argument principal, et retourne ses rsultats sous une forme plus conviviale, en gnral sous forme de tableau.

Ecrire un programme en R
Typiquement, un programme en R sera crit dans un fichier sauv au format ASCII et avec lextension .R. Bien quil existe un diteur sous R (R Editor) qui peut tre invoqu en cliquant dans le menu File sur la ligne New script, il ne fonctionne pas toujours comme il faut. Pour viter les inconvnients, vous pouvez utiliser tout simplement lditeur Bloc-notes de Windows et enregistrer votre programme avec lextension .R. La situation typique o un programme se rvle utile est lorsque lon veut excuter plusieurs fois une tche identique. Dans un premier exemple, on veut tracer le mme graphe pour trois espces de fleurs (iris) diffrentes, les donnes se trouvant dans trois fichiers distincts (qui nexistent pas dans donnesfournies par R, mais qui ont t fabriqus partir des donnes iris). layout(matrix(1:3, 3, 1)) # partitionne le graphique data <- read.table("set.dat") # lit les donnes plot(data$V1, data$V2, type="l") title("Iris setosa") # ajoute le titre data <- read.table("virg.dat") plot(data$V1, data$V2, type="l") title("Iris virginica") data <- read.table("versi.dat") plot(data$V1, data$V2, type="l") title("Iris Versicolor") Le caractre # sert ajouter des commentaires dans le programme, R passe alors la ligne suivante. Le problme de ce premier programme est quil risque de sallonger srieusement si lon veut ajouter dautres espces. De plus, certaines commandes sont rptes plusieurs fois, elles peuvent tre regroupes et excutes en modifiant les arguments qui changent. Les noms de fichier et despce sont donc utiliss comme des variables. La stratgie utilise ici est de mettre ces noms dans des vecteurs de mode caractre, et dutiliser ensuite lindexation pour accder leurs diffrentes valeurs. layout(matrix(1:3, 3, 1)) # partitionne le graphique species <- c("Iris setosa", "Iris virginica", "Iris Versicolor") file <- c("set.dat" , "virg.dat", "versi.dat") for(i in 1:length(species)) { data <- read.table(file[i]) # lit les donnes plot(data$V1, data$V2, type="l") title(species[i]) # ajoute le titre } On notera quil ny a pas de guillemets autour de file[i] dans read.table() puisque cet argument est de mode caractre. Notre programme est maintenant plus compact. Il est plus facile dajouter dautres espces car les deux vecteurs qui contiennent les noms despces et de fichiers sont dfinis au dbut du programme. Les programmes ci-dessus pourront marcher si les fichiers .dat sont placs dans le rpertoire de travail de R, sinon il faut soit changer ce rpertoire de travail, ou bien spcifier le chemin daccs dans le programme (par exemple : file <- "C:/data/set.dat"). Si les instructions sont crites dans un fichier MyIris.R, on peut appeler le programme en tapant : > source("MyIris.R") Comme pour toute lecture dans un fichier, il est ncessaire de prciser le chemin daccs au fichier sil nest pas dans le rpertoire de travail.

23

Ecrire ses fonctions

On a vu que lessentiel du travail de R se fait laide de fonctions dont les arguments sont indiqus entre parenthses. Lutilisateur peut crire ses propres fonctions qui auront les mmes proprits que les autres fonctions de R. Reprenons lexemple ci-dessus de la lecture de donnes dans un fichier suivi dun graphe. Si lon veut rpter cette opration quand on le veut, il peut tre judicieux dcrire une fonction : myfun <- function(S, F) { data <- read.table(F) plot(data$V1, data$V2, type="l") title(S) } Pour pouvoir tre excute, cette fonction doit tre charge en mmoire. On peut entrer les lignes de la fonction au clavier comme nimporte quelle commande, ou les copier/coller partir dun diteur. Si la fonction a t enregistre dans un fichier ASCII, on peut la charger avec source() comme un autre programme. Si lutilisateur veut que ses fonctions soient charges au dmarrage de R, il peut les enregistrer dans un workspace .RData qui sera charg en mmoire sil est localis dans le rpertoire de travail de dmarrage. On pourra par la suite, par une seule commande, lire les donnes et dessiner le graphe, par exemple myfun("Iris setosa", "set.dat"). Nous arrivons donc une troisime version de notre programme : layout(matrix(1:3, 3, 1)) myfun("Iris setosa", "set.dat") myfun("Iris virginica", "virg.dat") myfun("Iris versicolor", "versi.dat") On peut galement utiliser sapply() aboutissant une quatrime version du programme : layout(matrix(1:3, 3, 1)) species <- c("Iris setosa", "Iris virginica", "Iris versicolor") file <- c("set.dat" , "virg.dat", "versi.dat") sapply(species, myfun, file) Avec R, il nest pas ncessaire de dclarer les variables qui sont utilises dans une fonction (comme dans Matlab). Quand une fonction est excute, R utilise une rgle nomme tendue lexiquale (lexical scoping) pour dcider si un objet dsigne une variable locale la fonction ou un objet global. Pour comprendre ce mcanisme, considrons la fonction trs simple > foo <- function() print(x) > x <- 1 > foo() [1] 1 Le nom x na pas t utilise au sein de foo(), R va donc chercher dans lenvironnement immdiatement suprieur si un objet nomm x existe et affichera sa valeur (sinon un message derreur est affich et lexcution est termine). Si lon utilise x comme nom dobjet au sein de notre fonction, la valeur de x dans lenvironnement global nest pas modifie. > x <- 1 > foo2 <- function() { x <- 2; print(x) } > foo2() [1] 2 > x [1] 1 Cette fois print() a utilis lobjet x qui a t dfini dans son environnement, cest--dire celui de la fonction foo2. Le mot immdiatement ci-dessus est important. Dans les deux exemples que nous venons de voir, il y a deux environnements : le global et celui de la fonction foo ou foo2. Sil y avait trois ou plus

24

environnements embots, la recherche des objets se fait par paliers dun environnement lenvironnement immdiatement suprieur, ainsi de suite jusqu lenvironnement global. Il y a deux faons de spcifier les arguments une fonction : par leurs positions ou par leurs noms. Par exemple, considrons une fonction qui prendrait trois arguments : foo <- function(arg1, arg2, arg3) {...} On peut excuter foo() sans utiliser les noms arg1, . . ., si les objets correspondants sont placs dans lordre, par exemple : foo(x, y, z). Par contre, lordre na pas dimportance si les noms des arguments sont utiliss, par exemple : foo(arg3 = z, arg2 = y, arg1 = x). Une autre particularit des fonctions dans R est la possibilit dutiliser des valeurs par dfaut dans la dfinition. Par exemple : foo <- function(arg1, arg2 = 5, arg3 = FALSE) {...} Les deux commandes foo(x) et foo(x, 5, FALSE) auront exactement le mme rsultat. Lutilisation de valeurs par dfaut dans la dfinition dune fonction est bien sr trs pratique et ajoute la flexibilit du systme.

Les analyses statistiques avec R

Ce paragraphe est donn juste comme support pour les cours venir, essentiellement le cours de Rgression, et pour vos besoins ultrieurs, car certaines notions nont pas encore t rencontres dans vos cours jusqu maintenant.
Il est impossible ici daller dans les dtails sur les possibilits offertes par R pour les analyses statistiques. A lexception des fonctions dans les packages grid et lattice, toutes les fonctions que nous avons vues jusqu maintenant sont contenues dans le package base. Certaines fonctions pour lanalyse des donnes sont dans base mais la grande majorit des mthodes statistiques dans R sont distribues sous forme de package (voir les paragraphes prcdents). On se contentera ici de donner les notions qui sont utiles en gnral quelque soit le type danalyse que lon veut conduire et qui sont les formules et les fonctions gnriques.

Les formules
Les formules sont un lment-clef des analyses statistiques avec R : la notation utilise est la mme pour (presque) toutes les fonctions. Une formule est typiquement de la forme y ~ model o y est la rponse analyse et model est un ensemble de termes pour lesquels les paramtres sont estims. Ces termes sont spars par des symboles arithmtiques mais qui ont ici une signification particulire. effets additifs de a et de b si X est une matrice, ceci quivaut un effet additif de toutes ses colonnes, cest-`adire X[,1]+X[,2]+...+X[,ncol(X)]; certaines de ces colonnes peuvent tre slectionnes avec lindexation numrique (ex. : X[,2:4]) a:b effet interactif entre a et b a*b effets additifs et interactifs (identique `a a+b+a:b) poly(a, n) polynme de a jusquau degr n n inclue toutes les interactions jusquau niveau n, cest-`a-dire(a+b+c)2 est identique `a a+b+c+a:b+a:c+b:c b %in% a les effets de b sont hirarchiquement inclus dans a (identique a+a:b ou a/b) a-b supprime leffet de b, par exemple : (a+b+c)2-a:b est identique `a a+b+c+a:c+b:c -1 y ~ x-1 force la rgression passer par lorigine (idem pour y~x+0 ou 0+y~x) 1 y ~ 1 ajuste un modle sans effets (juste lintercept) a+b X

25

offset(...) ajoute un effet au modle sans estimer de paramtre (par ex., offset(3*x)) On voit que les oprateurs arithmtiques de R ont dans une formule un sens diffrent de celui quils ont dans une expression classique. Par exemple, la formule y ~ x1+x2 dfinira le modle y = 1 x1 + 2 x2 + , et non pas (si loprateur + avait sa fonction habituelle) y = ( x1 + x2 ) + . Pour inclure des oprations arithmtiques dans une formule, on utilisera la fonction I() : la formule y~I(x1+x2) dfinira alors le modle y = ( x1 + x2 ) + .
2 + on utilisera la formule y ~ poly(x, 2) De mme, pour dfinir le modle y = 1 x1 + 2 x2 (et non pas y ~ x + x2). Pour les analyses de variance, aov() accepte une syntaxe particulire pour spcifier les effets alatoires. Par exemple, y ~ a + Error(b) signifie effets additifs dun terme fixe (a) et dun terme alatoire (b).

Les fonctions gnriques

Les fonctions de R agissent en fonction des attributs des objets ventuellement passs en arguments. Les objets qui contiennent les rsultats dune analyse ont, quant eux, un attribut particulier nomm la classe qui contient la signature de la fonction qui a fait lanalyse. Les fonctions qui serviront ensuite extraire des informations de lobjet-rsultat agiront spcifiquement en fonction de la classe de lobjet. Ces fonctions sont dites gnriques. Par exemple, la fonction la plus utilise pour extraire des rsultats danalyse est summary qui permet dafficher les rsultats dtaills. Selon que lobjet qui est pass en argument est de classe "lm" (modle linaire) ou "aov" (analyse de variance), il est clair que les informations afficher ne seront pas les mmes. Lavantage des fonctions gnriques est davoir une syntaxe unique pour toutes les analyses. Un objet qui contient les rsultats dune analyse est gnralement une liste dont laffichage est dtermine par un attribut classe. On a dj vu cette notion que les fonctions de R agissent spcifiquement en fonction de la nature des objets qui sont donns en arguments. Cest un caractre gnral de R. Le tableau suivant donne les principales fonctions gnriques qui permettent dextraire des informations dun objet qui rsulte dune analyse. Lusage typique de ces fonctions tant : > mod <- lm(y ~ x) > df.residual(mod) [1] 8
print summary df.residual coef residuals deviance fitted logLik AIC retourne un rsum succint retourne un rsum dtaill retourne le nombre de degrs de libert rsiduel retourne les coefficients estims (avec parfois leurs erreurs-standards) retourne les rsidus retourne la dviance retourne les valeurs ajustes par le modle calcule le logarithme de la vraisemblance et le nombre de paramtre dun modle calcule le critre dinformation dAkaike ou AIC (dpend de logLik())

Une fonction comme aov ou lm produit donc une liste dont les diffrents lments correspondent aux rsultats de lanalyse. Les fonctions gnriques sont aussi appeles des mthodes. De faon schmatique, elles sont construites comme method.foo, o foo dsigne la fonction danalyse. Dans le cas de summary, on peut afficher les fonctions qui appliquent cette mthode et tapant la commande > apropos("summary") On peut visualiser les particularits de cette mthode dans le cas de la rgression linaire par rapport lanalyse de variance avec un exemple simul : > x <- y <- rnorm(5); > mod <- lm(y x)

26

> names(mod) [1] "coefficients" "residuals" "effects" [4] "rank" "fitted.values" "assign" [7] "qr" "df.residual" "xlevels" [10] "call" "terms" "model" > names(summary(mod)) [1] "call" "terms" "residuals" [4] "coefficients" "sigma" "df" [7] "r.squared" "adj.r.squared" "fstatistic" [10] "cov.unscaled" Le tableau suivant indique certaines fonctions gnriques qui font des analyses supplmentaires partir dun objet qui rsulte dune analyse faite au pralable, largument principal tant cet objet, mais dans certains un argument supplmentaire est ncessaire comme pour predict ou update.
add1 drop1 step anova predict update teste successivement tous les termes qui peuvent tre ajouts un modle teste successivement tous les termes qui peuvent tre enlevs dun modle slectionne un modle par AIC (fait appel add1 et drop1) calcule une table danalyse de variance ou de dviance pour un ou plusieurs modles calcule les valeurs prdites pour de nouvelles donnes partir dun modle r-ajuste un modle avec une nouvelle formule ou de nouvelles donnes

Il y a galement diverses fonctions utilitaires qui extraient des informations dun objet modle ou dune formule, comme alias() qui trouve les termes linairement dpendants dans un modle linaire spcifi par une formule.

27