Graphiques

R offre une variété de graphiques remarquable. Chaque fonction graphique a un nombre considérable d'options qui rendent la production de graphiques extrêmement flexible. Il est impossible de décrire ici l'ensemble des fonctions graphiques et leurs multiples options. Certaines de ces options peuvent être attribuées par par (voir help(par). Les démonstrations obtenues à l'aide de la commande demo(graphics) permettent de se faire une petite idée des possibilités graphiques offertes par R. Nous allons dans un premier temps donner quelques détails sur la gestion des fenêtres graphiques, puis énumérer les fonctions qui semblent les plus utiles.

Anatomie d'un tracéLes commandes de tracé génèrent des figures. Lorsqu'une commande de tracé est tapée sur la console, une fenêtre graphique va s'ouvrir automatiquement avec le graphique demandé. Il est possible d'ouvrir une autre fenêtre en tapant :

windows()    # sous windows
quartz()     # sous Mac OS
x11()        # sous linux/unix

La fenêtre ainsi ouverte devient la fenêtre active sur laquelle seront affichés les graphes suivants. Pour savoir les fenêtres graphiques qui sont ouvertes :

> dev.list()
windows windows
2 3

Les chiffres qui s'affichent correspondent aux numéros des fenêtres qui doivent être utilisés si l'on veut changer la fenêtre active :

> dev.set(2)
windows
2

La commande dev.off(i) supprime la fenêtre numéro i.

Une figure est composée d'une région dans laquelle s'effectue le tracé, entourée de marges. La taille des marges est contrôlée avec l'argument mai. Il s'agit d'un vecteur
c(bottom,left,top,right) de longueur 4 dont les valeurs des composantes sont les largeurs, en pouces, des marges correspondantes. Un appel typique de par() pour fixer les marges est

par(mai=c(5,5,8,5)/10)

qui permet d'avoir 0.8 pouces en haut et 0.5 pouces pour les autres côtés. Les axes, leurs étiquettes et les titres des figures apparaissent tous dans les marges de la figure.

Chaque marge est composée d'un nombre de lignes de texte :

• des lignes spécifiées en 0 correspondent aux bords de la région de tracé.
• des lignes avec des numéros plus élevés sont plus loin dans les marges du tracé.

Le paramètre graphique mar définit combien de lignes apparaîtront sur chacune des 4 marges.

Une autre fonction layout() partitionne la fenêtre graphique active en plusieurs parties sur lesquelles sont affichés les graphes successifs. Cette fonction est assez compliquée, par exemple, si l'on veut diviser la fenêtre en quatre parties égales :

 layout(matrix(c(1,2,3,4), 2, 2))

où le vecteur indique les numéros des sous-fenêtres, et les deux chiffres 2 que la fenêtre sera divisée en 2 dans le sens de la hauteur, et en 2 dans le sens de la largeur. Pour visualiser la partition créée par layout() avant de faire les graphes, on peut utiliser la fonction layout.show(2), si par exemple deux sous-fenêtres ont été définies. Une autre manière de tracer plusieurs figures sur la même fenêtre graphique en les disposant selon un tableau à $n \times m$ figures est donnée par par(mfrow=c(n,m)). Par exemple par(mfrow=c(3,2)) produira une région de tracé sur laquelle seront disposées 6 figures en 3 lignes et 2 colonnes.

Il existe de nombreuses fonctions graphiques dans R. Les énumerer serait trop long, mais l'aide en ligne sur help(plot) et help(par) donne une description utile des commandes pour l'habillage des graphes (légendes, axes, texte, mise en forme, marges, couleurs, ...) et n'est donc pas répété ici.

Représenter des fonctionsLe plus simple pour commencer est de tracer le graphe d'une fonction de $\mathbb{R}$ dans $\mathbb{R}$ à l'aide de plot. On crée pour cela un vecteur x d'abscisses, et on prend l'image de ce vecteur par la fonction pour créer un vecteur y d'ordonnées. La commande plot(x,y) représente les points de coordonnées (x[i],y[i]) en y traçant des symboles définis par la paramètre pch de valeurs possibles allant de 0 à 18 traits noirs (par défaut pch=1). Les points sont représentés par pch=. ou pch=o), ou selon un autre style. La qualité de la représentation dépend bien sûr du nombre de points.

x<-seq(0,3*pi, length=10); y<-x*sin(x)
plot(x,y)           # les points sont tracés avec le symbole o
plot(x,y, pch=16)   # les points sont tracés avec le symbole o noirci
plot(x,y, type="l") # les points sont reliés par des segments
x<-seq(0,3*pi, length=100); y=<-x*sin(x)
plot(x,y)

Quand on veut superposer plusieurs courbes avec les mêmes échelles de représentation, il est préférable d'utiliser plot d'abord avec type=n qui autorise le tracé des axes et la bonne échelle et ensuite des appels aux fonctions lines ou points qui permet le tracé avec des styles différents pour chaque courbe. La syntaxe générale est la suivante.

x<-seq(0,3*pi,length=30)
y<-x*sin(x)
y2<-2*y;
plot(x,y2, type="n")
y2<-2*y;
lines(x,y2)        # échelles différentes adaptées
lines(x,y)
points(x,y2,pch=16)

On peut également réaliser un graphique composé à l'aide de la libraire ggplot2. Ainsi par exemple, les commandes suivantes produisent la figure 1 :

library(ggplot2)> df<-as.data.frame(cbind(x,y))
x<-seq(0,3*pi,length=30)
y<-x*sin(x)
df<-as.data.frame(cbind(x,y))
names(df)<-c("x","y")
p<-ggplot(df,aes(x,y))
p+geom_line(aes(y=y),colour="red")+ geom_area(fill="grey")
      +geom_line(aes(y=2*y),colour="blue")

Figure 1: Figure composée.

Il est fréquent qu'un graphique contienne non seulement une ou plusieurs représentations de fonctions, mais aussi des chaînes de caractères. Ainsi par exemple le code suivant produit les histogrammes de la figure 2 :

library(MASS)
data(crabe)      # on charge les données crabe
x <- crabs$FL
y <- crabs$CL 
op <- par(mfrow=c(2,1))
 hist(x, col="light blue", xlim=c(0,50))
 hist(y, col="light blue", xlim=c(0,50))
par(op)

Figure 2: Histogrammes

Figure 3: Représentation par courbes de niveau.

Des fonctions prédéfinies permettent d'effectuer des représentations planes particulières, comme des projections de surfaces par courbes de niveau ou niveaux de gris, ou des champs de vecteurs. Les exemples qui suivent en sont des illustrations.

library(chplot)
data(hdr)
x <- hdr$age
y <- log(hdr$income)
library(MASS)
z <- kde2d(x,y, n=50)
image(z, main = "niveaux de gris")
{contour(z, col = "red", drawlabels = FALSE,
         main = "courbes de niveau")}
persp(z, main = "tracée de surface en perspective")

Figure 4: Représentation par niveaux de gris.

Figure 5: Représentation en perspective