logique formula -niveau

Ceci est un extrait électronique d'une publication de
Diamond Editions :
http://www.ed-diamond.com
Ce fichier ne peut être distribué que sur le CDROM offert
accompagnant le numéro 100 de GNU/Linux Magazine France.
La reproduction totale ou partielle des articles publiés dans Linux
Magazine France et présents sur ce CDROM est interdite sans accord
écrit de la société Diamond Editions.
Retrouvez sur le site tous les anciens numéros en vente par
correspondance ainsi que les tarifs d'abonnement.
Pour vous tenir au courant de l'actualité du magazine, visitez :
http://www.gnulinuxmag.com
Ainsi que :
http://www.linux-pratique.com
et
http://www.miscmag.com
sciences/techno
statistiques
 R : Programmer avec des données*
Yves Croissant
EN DEUX MOTS R est un Logiciel libre, qui est un
dialecte de S, langage de programmation pour les
analyses statistiques développé dans les années
80 aux laboratoires Bell, en particulier par John
Chambers. R a été écrit initialement par Ross
Ihaka et Robert Gentleman et est actuellement
développé par une petite équipe de développeurs
(R Core Development Team). Il est distribué sous
les termes de la GNU public licence.
est disponible sous la forme de
fichiers exécutables pour tous les
systèmes d’exploitation courants :
Linux (Debian, Red Hat, Mandrake
et Suse),Windows et MacOS. Il est également
disponible sous forme de sources.
Le site de R est : http://www.r-project.
org.
Les liens suivants sont particulièrement
intéressants :
 CRAN : pour télécharger R. Il faut d’abord
choisir un site miroir, puis télécharger
le logiciel.
D
ocumentation : les manuels de R sont
un peu austères pour les débutants. Dans
la section Other, on trouve plusieurs
documents plus accessibles. Notons
en particulier « R pour les débutants »
d’Emmanuel Paradis.
L
e lien Search est également très utile
afin de trouver comment une fonction
particulière est implantée dans R.
Une fois le logiciel installé, il peut être lancé
à partir d’un terminal en entrant simplement
R. Une ligne débutant par le signe > apparaît
alors. Une expression écrite après ce signe
suivie d’un retour chariot est alors évaluée
par R.
Cette manière de procéder permet de
travailler en mode interactif. Pour un usage
régulier, il est préférable de travailler avec
un éditeur de texte. emacs (http://www.
gnu.org/software/emacs/ ) dispose d’une
librairie appelée ess (emacs speaks statistics)
permettant de travailler avec R (ainsi qu’avec
d’autres logiciels de statistique).
Les commandes sont alors entrées
dans un fichier et peuvent être évaluées
88
individuellement ou par bloc dans la console de R. Le site
de cette librairie est : http://ess.r-project.org.
1. Les différents objets
R est un langage fonctionnel.Toute fonction crée un résultat
qui est stocké dans un objet, c’est-à-dire une structure
de donnée dotée de différentes fonctions permettant de
manipuler ces données de manière appropriée. Chaque fonction
dispose d’une aide en ligne, que l’on peut consulter en tapant
help(fonction) ou plus simplement ?fonction.
Une fonction admet en général un ou plusieurs arguments,
certains obligatoires, d’autres facultatifs, qui peuvent être
renseignés en respectant l’ordre de ces arguments, ou à l’aide
d’une syntaxe clé-valeur. Par exemple, la fonction lm, que l’on
verra ultérieurement, a pour deux premiers arguments formula
et data. Les trois syntaxes ci-dessous sont équivalentes :
> lm(formula=x,data=y)
> lm(x,y)
> lm(data=y,formula=x)
Même si R n’est pas réellement un langage orienté objet,
il en possède certaines caractéristiques qui facilitent la
programmation. Nous présenterons dans cette section les
principaux objets utilisés par R.
1.1 Les vecteurs
L’objet de base est le vecteur. La fonction c() permet de
créer un vecteur.
> c(1, 2, 3, 4)
[1] 1 2 3 4
Le résultat de la commande précédente crée un vecteur
numérique et l’imprime.
> w <- c(1, 2, 3, 4, 2, 6, 4)
> w
[1] 1 2 3 4 2 6 4
La commande ci-dessus est quasiment équivalente. La différence
est que le résultat de la commande est stocké dans un nouvel
objet appelé w au moyen de l’opérateur d’assignation <- (qui
peut être remplacé par le signe =).
La seconde commande w (équivalente à print(w)), imprime
cet objet. Chaque objet est caractérisé par un certain nombre
d’attributs. Pour l’objet de base (le vecteur), ils sont au nombre
de deux : le mode et la longueur. Ces attributs peuvent être
extraits à l’aide de fonctions homonymes.
> mode(w)
[1] «numeric»
> length(w)
[1] 7
 GNU Linux Magazine France
Le mode de w est numeric. Les autres modes possibles pour
un vecteur sont character et logical.
> z <- c(«un», «deux», «trois»)
> y <- c(F, T, F, F)
> z
[1] «un» «deux» «trois»
> y
[1] FALSE TRUE FALSE FALSE
> mode(z)
[1] «character»
> mode(y)
[1] «logical»
Des vecteurs peuvent être également créés au moyen de
séquences (fonction seq), ou par répétition d’un même
vecteur (fonction rep) :
> seq(1, 4, 0.5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0
> seq(1, 4)
[1] 1 2 3 4
> rep(c(1, 2), 5)
[1] 1 2 1 2 1 2 1 2 1 2
La fonction seq prend comme arguments la valeur initiale
de la séquence, la valeur finale et le pas d’incrémentation. Si
ce dernier argument est manquant, il est par défaut égal à 1.
Le même résultat peut alors être plus simplement obtenu à
l’aide de la commande 1:4.
R dispose d’un puissant mécanisme d’indiçage qui permet
d’extraire aisément certains éléments d’un vecteur. Dans
l’exemple ci-dessous, on extrait successivement les éléments
1, 4 et 5, puis les éléments de 1 à 3 et enfin les éléments 1,
2,3 et 5.
> w[c(1, 4, 5)]
[1] 1 4 2
> w[1:3]
[1] 1 2 3
> w[c(1:3, 5)]
[1] 1 2 3 2
Dans tous les cas, on indique entre crochets un vecteur dans
lequel figurent les indices des éléments du vecteur initial que
l’on souhaite sélectionner.
On peut également indiquer entre crochets un vecteur
logique de même longueur que le vecteur d’intérêt. Dans ce
cas, seront extraits les éléments du vecteur pour lesquels les
éléments du vecteur logique correspondant sont vrais.
> w > 3
[1] FALSE FALSE FALSE TRUE FALSE TRUE TRUE
> w[w > 3]
[1] 4 6 4
> w == 2
[1] FALSE TRUE FALSE FALSE TRUE FALSE FALSE
> w[w == 2]
[1] 2 2
Numéro 83 / Mai 2006
L’expression w>3 crée un vecteur logique
de même longueur que w dont les valeurs
sont vraies si l’élément correspondant de
w est supérieur à 3. De la même manière,
w==2 crée un vecteur logique dont les
valeurs sont vraies pour les éléments de
w égaux à 2. w[w>3] et w[w==2] extraient
respectivement du vecteur w un vecteur
contenant les valeurs de w supérieures à 3
et égales à 2.
On peut également nommer les éléments d’un
vecteur en ajoutant un attribut supplémentaire,
les noms, à ce vecteur.
> x <- c(1, 4, 3, 8)
> names(x) <- c(«dupont», «durand», «martin», «jourdain»)
> x
dupont durand martin jourdain
1
4
3
8
La commande attributes(x) permet
d’imprimer les attributs de x. On vérifie
que cet objet est bien doté d’un attribut
supplémentaire appelé names.
Une dernière méthode d’extraction consiste
à indiquer entre crochets un vecteur de
noms.
> x[c(«dupont», «martin»)]
dupont martin
1
3
1.2 Les tableaux et les
matrices
Un tableau (array) est un vecteur qui
dispose d’un attribut supplémentaire, la
dimension.
Une matrice (matrix) est un tableau à deux
dimensions. Les différentes commandes
ci-dessous permettent d’obtenir la même
matrice.
> x = 1:9
> dim(x) = c(3, 3)
> x
[1,]
[2,]
[3,]
[,1] [,2] [,3]
1
4
7
2
5
8
3
6
9
> mode(x)
[1] «numeric»
> class(x)
[1] “matrix”
> x = 1:9
> matrix(x, 3, 3)
[,1] [,2] [,3]
[1,]
1
4
7
[2,]
2
5
8
[3,]
3
6
9
> matrix(x, 3, 3, byrow = T)
[,1] [,2] [,3]
89
sciences/techno
statistiques
[1,]
[2,]
[3,]
1
4
7
2
5
8
3
6
9
Dans le premier cas, on ajoute au vecteur x
un attribut dim. On obtient alors une matrice
3X3. Le mode de x est toujours numeric.
En revanche, la classe de x est désormais
une matrice.
Dans le second cas, on utilise la fonction
matrix qui a pour arguments les éléments
de la matrice, le nombre de lignes et le
nombre de colonnes (et éventuellement
byrow qui est FALSE par défaut et qui indique
si la matrice doit être remplie ligne par ligne
ou colonne par colonne).
On peut ensuite appliquer aux matrices
différentes opérations. +,-,/,* réalisent
des opérations élément par élément. La
multiplication matricielle est réalisée au
moyen de l’opérateur %*%.
La transposition et l’inverse de la matrice x
s’écrivent respectivement t(x) et solve(x).
Comme pour les vecteurs, on peut attribuer
des noms aux lignes et aux colonnes d’une
matrice, à l’aide des fonctions rownames et
colnames.
> attributes(z)
$levels
[1] «jamais» «rarement» «souvent»
$class
[1] «factor»
1.4 Les listes et les data.frame
Une liste permet de stocker dans un objet un ensemble d’objets
qui peuvent être de modes et de longueurs différentes.
> logic <- c(F, T, T, F, F, T)
> char <- c(«bonjour», «aurevoir»)
> num <- 4
> z <- list(logic, char, num)
> class(z)
[1] “list”
On peut extraire les différents éléments de la liste en indiçant
celle-ci entre crochets. De simples crochets définissent une
sous-liste, des crochets doubles rétablissent la classe de
l’élément concerné.
> z[c(1, 3)]
[[1]]
[1] FALSE TRUE TRUE FALSE FALSE TRUE
[[2]]
[1] 4
> x <- matrix(1:9, 3, 3)
> z[2]
[[1]]
[1] “bonjour” “aurevoir”
> rownames(x) <- c(«un», «deux», «trois»)
> class(z[2])
[1] «list»
> colnames(x) <- c(«a», «b», «c»)
> z[[2]]
[1] “bonjour” “aurevoir”
> x
> class(z[[2]])
[1] «character»
a
un
1
deux 2
trois 3
b
4
5
6
c
7
8
9
1.3 Les facteurs
Un facteur est un vecteur avec un attribut
supplémentaire, les niveaux (levels). Il
permet de définir une variable catégorielle,
en utilisant la commande factor.
> x <- c(1, 2, 2, 1, 0, 2, 1, 0)
> z <- factor(x)
> z
[1] 1 2 2 1 0 2 1 0
Levels: 0 1 2
> attributes(z)
$levels
[1] “0” “1” “2”
$class
[1] “factor”
On peut également donner un nom plus
explicite aux niveaux de la variable en
utilisant l’argument labels.
90
> z <- factor(x, labels = c(«jamais», «rarement», «souvent»))
Les listes peuvent être plus aisément manipulées si leurs
différents éléments sont nommés. On peut alors extraire
un élément de z en utilisant le nom de cet élément préfixé
de z$.
> names(z) <- c(«a», «b», «c»)
> z$a
[1] FALSE TRUE TRUE FALSE FALSE TRUE
On peut aussi nommer les éléments de la liste au moment
de sa création au moyen de la commande suivante :
> z <- list(a = logic, b = char, c = num)
Un tableau de données (data.frame) est une liste qui contient
un ensemble de vecteurs ayant tous la même longueur (mais
pas forcément le même mode). C’est le format d’objet que
l’on utilise pour stocker des données.
> nom <- c(«durand», «dupont», «dupond», «martin», «pinault»,
«vaillant»)
> marie <- c(T, F, T, T, F, F)
> age <- c(40, 28, 41, 58, 35, 32)
> csp <- c(«artisan», «ouvrier», «ouvrier», «employé», «artisan»,
+
«artisan»)
 GNU Linux Magazine France
R : Programmer avec des données
> base <- list(nom = nom, marie = marie, age = age, csp = csp)
> base
$nom
[1] «durand» «dupont» «dupond» «martin» «pinault» «vaillant»
$marie
[1] TRUE FALSE TRUE TRUE FALSE FALSE
$age
[1] 40 28 41 58 35 32
$csp
[1] “artisan” “ouvrier” “ouvrier” “employé» «artisan» «artisan»
> base$marie
[1] TRUE FALSE TRUE TRUE FALSE FALSE
Un tableau de données peut être obtenu à partir de la
fonction data.frame, qui prend pour argument une liste ou
un ensemble de vecteurs.
> summary(cars)
speed dist
Min. : 4.0 Min. : 2.00
1st Qu.:12.0 1st Qu.: 26.00
Median :15.0 Median : 36.00
Mean :15.4 Mean : 42.98
3rd Qu.:19.0 3rd Qu.: 56.00
Max. :25.0 Max. :120.00
Pour visualiser la distribution de la variable de
distance (dist) au moyen d’un histogramme,
on utilise la commande hist :
> hist(cars$dist)
> base2 <- data.frame(base)
> class(base2)
[1] “data.frame”
> base2
nom marie
1 durand TRUE
2 dupont FALSE
3 dupond TRUE
4 martin TRUE
5 pinault FALSE
6 vaillant FALSE
age
40
28
41
58
35
32
csp
artisan
ouvrier
ouvrier
employé
artisan
artisan
Notons que les tableaux de données, contrairement aux
listes ordinaires, sont dotés d’une méthode d’impression
tabulaire.
1.5 Les fonctions de regroupement
La fonction table permet d’obtenir une table de fréquence
pour une variable catégorielle.
> table(base2$csp)
artisan employé ouvrier
3
1
2
La fonction tapply permet d’appliquer une opération à
une variable numérique, conditionnellement à une variable
catégorielle. Par exemple, pour connaître l’âge moyen dans
notre échantillon selon la csp :
> tapply(base2$age, base2$csp, mean)
artisan employé ouvrier
35.66667 58.00000 34.50000
2. Un exemple d’utilisation de R
Nous utiliserons ici des données indiquant la vitesse (en
miles par heure) et la distance de freinage (en pieds) de
différentes voitures. Ces données sont fournies avec R, on
peut donc obtenir un data.frame appelé cars simplement
avec la commande :
> data(cars)
Comme les fonctions, les données disposent d’une aide en
ligne et on peut donc obtenir davantage d’informations sur
ces données avec la commande ?cars. Commençons par
afficher des statistiques descriptives :
Numéro 83 / Mai 2006
La relation entre les deux variables peut être
appréhendée par une droite de régression
linéaire.
Le calcul des paramètres de la droite est
réalisé à l’aide de la fonction lm. x où print(x)
indique des résultats sommaires sur le
modèle estimé, la commande summary(x)
calcule (et imprime si ces résultats ne sont
pas stockés dans un objet) des résultats
détaillés sur le modèle.
> x = lm(dist ~ speed, data = cars)
> print(x)
Call:
lm(formula = dist ~ speed, data = cars)
Coefficients:
(Intercept)
speed
-17.579 3
.932
> summary(x)
Call:
lm(formula = dist ~ speed, data = cars)
Residuals:
Min
1Q Median
3Q
Max
-29.069 -9.525 -2.272 9.215 43.201
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) -17.5791
6.7584 -2.601 0.0123 *
speed
3.9324
0.4155 9.464 1.49e-12 ***
---
91
sciences/techno
statistiques
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ‘ 1
Residual standard error: 15.38 on 48 degrees of freedom
Multiple R-Squared: 0.6511, Adjusted R-squared: 0.6438
F-statistic: 89.57 on 1 and 48 DF, p-value: 1.490e-12
Le premier argument de la commande
lm est une formule (formula). Il s’agit
d’une description symbolique du modèle
d’intérêt : « dist en fonction de speed »
s’écrit dist~speed.
Le second argument est le tableau de données
contenant les données. Le résultat est
stocké dans un objet x de classe lm. Il s’agit
d’une liste contenant différents résultats
du modèle.
On peut imprimer les différents éléments
de cette liste en tapant names(x) et extraire,
par exemple, les paramètres de la droite
de régression linéaire avec la commande
x$coefficients.
Notons l’utilisation de la commande summary :
il s’agit d’une fonction générique permettant
d’obtenir un résumé de l’objet indiqué en
argument. Son comportement s’adapte au
type d’objet considéré.
On a vu précédemment que s’il s’agit d’un
data.frame, elle calcule des statistiques
descriptives alors qu’ici, elle calcule différents
indicateurs statistiques concernant le
modèle estimé. Les résultats indiquent
qu’une augmentation de 1 mile par heure
de la vitesse se traduit en moyenne par une
augmentation de la distance de freinage de
3.9 pieds. Cette relation peut également
être visualisée à l’aide d’un graphique de
type (x,y) :
De nombreux paramètres peuvent être spécifiés pour
personnaliser un graphique, soit à l’aide de la commande par
(modification globale des paramètres), soit en argument de la
commande graphique (modification locale). Des renseignements
peuvent être obtenus sur les différents paramètres graphiques
en affichant la page d’aide de par.
La figure ci-dessous présente le résultat de l’utilisation
de différents paramètres graphiques : un fond bleu clair
(par(bg=»lightsteelblue»)), des axes « en L » (bty) un titre
principal et pour les axes (main, xlab et ylab), des étiquettes
positionnées verticalement (las), des points en diamant
(pch), des tailles de caractères personnalisées (cex.main et
cex.lab), etc.
> par(bg = «lightsteelblue»)
> plot(dist ~ speed, data = cars, bty = «l», main = «Distance et
vitesse»,
+ fg = «blue», xlab = «vitesse», ylab = «distance», las = 1,
+ pch = 9, col.lab = «navy», cex.main = 2, cex.lab = 1.5, xlim = c(0,
+ 25), xaxs = «i», ylim = c(0, 120), yaxs = «i»)
> abline(x, lty = «dashed», col = «sienna»)
> plot(dist ~ speed, data = cars)
La commande plot est une commande
graphique primaire, qui ouvre une nouvelle
fenêtre graphique. Des commandes graphiques
secondaires peuvent être utilisées, qui
permettent d’ajouter des éléments graphiques
supplémentaires sur le graphique existant.
Par exemple, la commande abline permet
de tracer une droite.
Différentes syntaxes sont possibles, par
exemple abline(1,2) trace une droite
d’ordonnée à l’origine égale à 1 et de pente
égale à 2. Cette commande peut également
avoir comme argument un objet renvoyé par
la commande lm. La droite de régression
est alors tracée.
> plot(dist ~ speed, data = cars)
> abline(x)
92
3. Programmer avec R
Pour illustrer la programmation avec R, nous reprenons le
même exemple que dans la section précédente. Nous voulons
écrire des fonctions qui permettent de calculer les coefficients
d’une droite de régression linéaire et d’afficher le nuage de
points et la droite de régression. En notant classiquement
y la variable expliquée et x la variable explicative, les deux
paramètres de la droite sont donnés par :
 GNU Linux Magazine France
R : Programmer avec des données
On obtient alors le code initial suivant :
> y <- cars$dist
> x <- cars$speed
> n <- length(y)
> xbar <- mean(x)
> ybar <- mean(y)
> b <- (sum(x * y) - n * xbar * ybar)/(sum(x^2) - n * xbar^2)
> a <- ybar - b * xbar
> c(a, b)
[1] -17.579095 3.932409
> plot(y ~ x)
> abline(a, b)
Listing 2 : La fonction mco avec attribut de classe
Listing 3 : Une fonction print pour mco
Listing 1 : La fonction mco
Le nombre de décimales imprimées peut être
contrôlé en utilisant la fonction round.
La version de la fonction print.mco présentée
dans le listing 4 utilise cette possibilité en
ajoutant en plus decimales comme argument
optionnel.
On utilise les fonctions lenght, mean et sum qui renvoient
respectivement la longueur, la moyenne et la somme des
éléments d’un vecteur. Les deux paramètres de la droite sont
ensuite rassemblés dans un vecteur et imprimés.
3.1 Écriture d’une fonction simple
Écrivons maintenant une fonction permettant de calculer les
paramètres de la droite (voir listing 1). L’objet res renvoyé
par la fonction est une liste.
> z <- mco(cars$dist, cars$speed)
> z
$a
[1] -17.57909
$b
[1] 3.932409
On constate que l’impression de z correspond à celui d’une
liste classique.
3.2 Classe et méthode générique
Pour obtenir une impression personnalisée, on peut créer
une classe pour l’objet renvoyé par la fonction mco et écrire
une méthode d’impression personnalisée.
Cette méthode sera écrite dans une fonction appelée print.
mco. Plus généralement, le nom de la fonction contenant une
méthode générique methode pour un objet de classe classe
s’appellera methode.classe. La nouvelle fonction mco est
présentée dans le listing 2.
La seule modification est qu’un attribut class est ajouté.
La fonction print.mco (listing 3) utilise la commande paste
afin de créer une chaîne de caractère à partir de chaînes de
caractère ou de variables numériques. La fonction cat permet
d’imprimer une chaîne de caractère (la chaîne \n correspond
à un retour à la ligne).
Numéro 83 / Mai 2006
Listing 4 : Une fonction print pour mco (2)
On vérifie que z ou print(z) réalisent
l’impression par défaut (3 chiffres après la
virgule) alors que print(z,decimales=5)
affiche les paramètres avec 5 décimales.
> z <- mco(cars$dist, cars$speed)
> z
ordonnee à l’origine : -17.579
pente : 3.932
> print(z, decimales = 5)
ordonnee à l’origine : -17.57909
pente : 3.93241
plot est au même titre que print une
fonction générique. On peut donc écrire
une méthode graphique spécifique pour les
objets de classe mco.
Cependant, si l’on souhaite que sur ce
graphique figure le nuage de point, il est
nécessaire de redéfinir l’objet mco, puisqu’il
ne contient pour l’instant que les paramètres
de la droite.
93
sciences/techno
statistiques
> z
moyennes de x et de y : 15.4 et 42.98
ordonnee à l’origine : -17.579
pente
: 3.932
On peut désormais écrire la fonction graphique, présentée
dans le listing 7. Notons l’utilisation de .... Cela permet
d’utiliser dans la fonction plot des arguments supplémentaires
permettant de personnaliser le graphique. Par exemple, pour
modifier les points et ajouter un titre, on pourra utiliser :
Listing 5 : Fonction mco renvoyant les données et les paramètres
> plot(z, pch = 10, main = «distance et vitesse»)
Listing 6 : Une fonction print pour mco (3)
Listing 7 : Une fonction plot pour mco
Un objet de classe mco sera désormais
une liste de deux listes, l’une contenant les
paramètres estimés, l’autre les données
(voir listing 5).
On a également ajouté un attribut à cet
objet, les moyennes des deux variables. La
fonction print doit prendre en compte ces
modifications de structure (voir listing 6).
Nous lui ajoutons l’impression des moyennes
des deux variables.
> z <- mco(cars$dist, cars$speed)
> z$param
$a
[1] -17.57909
$b
[1] 3.932409
> z$donnees$x[1:5]
[1] 4 4 7 7 8
> attr(z, “moyennes”)
$xbar
[1] 15.4
$ybar
[1] 42.98
94
3.3 Écrire une fonction générique
La fonction mco prend pour arguments deux vecteurs, la
variable expliquée et la variable explicative. Avec R, il est en
général préférable lorsque l’on programme un estimateur
d’utiliser une formule (y~x).
Nous souhaitons désormais étendre les possibilités de la
fonction mco de manière à ce qu’elle permette d’utiliser comme
argument soit une formule, soit deux vecteurs. L’idée est de
commencer par écrire une fonction spécifique qui permet de
traiter correctement le cas où le premier argument de mco
est une formule, d’extraire de la formule x et y et d’utiliser
ensuite la fonction mco initiale.
mco est désormais une fonction générique (voir listing 8), dont
le comportement s’adapte à la classe de son premier argument :
s’il s’agit d’une formule, c’est la fonction mco.formula qui est
appelée, sinon il s’agit de la fonction mco.default. Détaillons
les différentes lignes de la fonction mco.formula :
 mf <- model.frame(x,data=data) : la fonction model.frame
prend comme argument une formule et un tableau de
données. Elle renvoie un tableau de données contenant
toutes les variables nécessaires pour utiliser la formule.
 t m <- attr(mf,»terms») : l’attribut terms de mf est extrait
: il contient toutes les informations nécessaires sur les
 GNU Linux Magazine France
R : Programmer avec des données
Listing 8 : Une fonction mco générique
variables explicatives (classe de ces variables, effets
interactifs etc.).
 y <- model.response(mf) : cette fonction prend pour
argument un objet model.frame et renvoie un vecteur
contenant la variable expliquée.
 x <- model.matrix(tm,mf)[,2] : la fonction model.matrix
prend pour argument deux objets terms et model.frame
et renvoie la matrice des variables explicatives. Celle-ci
est ici composée de deux colonnes : un vecteur de 1
(par défaut, une constante est ajoutée à la formule) et la
variable d’intérêt. On sélectionne ici la seconde colonne
de cette matrice.
 r es <- mco(y,x) : on appelle la fonction mco avec comme
arguments deux vecteurs. C’est donc la fonction mco.
default qui est utilisée.
On vérifie ci-dessous que les deux syntaxes sont désormais
acceptées :
> mco(dist ~ speed, data = cars)
moyennes de x et de y : 15.4 et 42.98
ordonnee à l’origine : -17.579
pente
: 3.932
> mco(cars$dist, cars$speed)
moyennes de x et de y : 15.4 et 42.98
ordonnee à l’origine : -17.579
pente
: 3.932
4. Pour aller plus loin
L
e document de Pascal Paradis « R pour les débutants »,
cité en introduction, présente en détail les éléments
essentiels du langage R.
 Il existe de nombreux livres (en anglais) concernant S ou R.
On trouvera les références de ces ouvrages en suivant les
liens Documentation Books sur le site de R. S Programming
Numéro 83 / Mai 2006
de W.N. Venables et B.D. Ripley (2000,
éditions Springer) est particulièrement
intéressant pour une utilisation avancée
de R.
 Les pages d’aide des fonctions contiennent
une rubrique examples. On peut apprendre
beaucoup en évaluant ces exemples et en
analysant le résultat, en particulier pour
les commandes graphiques.
L
e lien CRAN Packages permet d’accéder
à la liste des librairies écrites par des
utilisateurs qui permettent d’accroître les
possibilités de R. Il y a plusieurs moyens
d’installer des librairies. Par exemple, si
l’on dispose d’une connexion internet,
l’installation de la librairie abind, peut être
obtenue en lançant R d’un terminal en
tant que super-utilisateur et en entrant la
commande library.install(abind). Une
fois que la librairie est installée, on accède
à ses fonctionnalités avec la commande
library(abind).
R
dispose de fonctionnalités permettant
de l’utiliser avec LaTeX. En particulier, un
graphique peut être sauvegardé au format
postscript pour une insertion ultérieure
dans un document LaTeX à l’aide de la
commande suivante :
postscript(«mongraphique.ps»)
plot(...
dev.off()
La librairie xtable permet de transformer
un tableau issu de R en un tableau au format
LATEX ou html.
Enfin, Sweave (voir ?Sweave) permet de
rassembler dans un même document le code
R et les commentaires en LaTeX.
R
dispose également de librairies (RMySQL
et RSQLite) permettant d’interfacer les
systèmes de gestion de bases de données
MySQL et SQLite. On peut alors lancer
une requête à partir de R et récupérer les
résultats dans un tableau de données.

note
*Titre de l’ouvrage de référence sur le
langage S : Programming with data de John
Chambers.
Yves Croissant,
95