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.
88
GNU LINUX MAGAZINE FRANCE
89
est disponible sous la forme de
chiers 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.
 Documentation : 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.
 Le lien Search est également très utile
an 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 chier et peuvent être évaluées
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 :
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.
Le résultat de la commande précédente crée un vecteur
numérique et l’imprime.
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.
> lm(formula=x,data=y)
> lm(x,y)
> lm(data=y,formula=x)
> c(1, 2, 3, 4)
[1] 1 2 3 4
> w <- c(1, 2, 3, 4, 2, 6, 4)
> w
[1] 1 2 3 4 2 6 4
> mode(w)
[1] «numeric»
> length(w)
[1] 7

Numéro 83 / Mai 2006
88
GNU LINUX MAGAZINE FRANCE
89
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.
La commande attributes(x) permet
d’imprimer les attributs de x . On vérie
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.
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.
Le mode de w est numeric . Les autres modes possibles pour
un vecteur sont character et 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 ) :
La fonction seq prend comme arguments la valeur initiale
de la séquence, la valeur nale 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 enn les éléments 1,
Dans tous les cas, on indique entre crochets un vecteur dans
lequel gurent 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.
> 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»
> 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
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
> 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
> x <- c(1, 4, 3, 8)
> names(x) <- c(«dupont», «durand», «martin», «jourdain»)
> x
dupont durand martin jourdain
1 4 3 8
> x[c(«dupont», «martin»)]
dupont martin
1 3
> x = 1:9
> dim(x) = c(3, 3)
> x
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 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]

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 .
1.3 Les facteurs
Un facteur est un vecteur avec un attribut
supplémentaire, les niveaux ( levels ). Il
permet de dénir une variable catégorielle,
en utilisant la commande factor .
On peut également donner un nom plus
explicite aux niveaux de la variable en
utilisant l’argument labels .
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.
On peut extraire les différents éléments de la liste en indiçant
celle-ci entre crochets. De simples crochets dénissent une
sous-liste, des crochets doubles rétablissent la classe de
l’élément concerné.
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éxé
de z$ .
On peut aussi nommer les éléments de la liste au moment
de sa création au moyen de la commande suivante :
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.
SCIENCES/TECHNO STATISTIQUES R : Programmer avec des données
90
GNU LINUX MAGAZINE FRANCE
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
> x <- matrix(1:9, 3, 3)
> rownames(x) <- c(«un», «deux», «trois»)
> colnames(x) <- c(«a», «b», «c»)
> x
a b c
un 1 4 7
deux 2 5 8
trois 3 6 9
> 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”
> z <- factor(x, labels = c(«jamais», «rarement», «souvent»))
> attributes(z)
$levels
[1] «jamais» «rarement» «souvent»
$class
[1] «factor»
> logic <- c(F, T, T, F, F, T)
> char <- c(«bonjour», «aurevoir»)
> num <- 4
> z <- list(logic, char, num)
> class(z)
[1] “list”
> z[c(1, 3)]
[[1]]
[1] FALSE TRUE TRUE FALSE FALSE TRUE
[[2]]
[1] 4
> z[2]
[[1]]
[1] “bonjour” “aurevoir”
> class(z[2])
[1] «list»
> z[[2]]
[1] “bonjour” “aurevoir”
> class(z[[2]])
[1] «character»
> names(z) <- c(«a», «b», «c»)
> z$a
[1] FALSE TRUE TRUE FALSE FALSE TRUE
> z <- list(a = logic, b = char, c = num)
> 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»)

Numéro 83 / Mai 2006
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.
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.
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 :
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 :
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
afcher des statistiques descriptives :
SCIENCES/TECHNO STATISTIQUES R : Programmer avec des données
91
Pour visualiser la distribution de la variable de
distance ( dist ) au moyen d’un histogramme,
on utilise la commande hist :
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.
> 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
> base2 <- data.frame(base)
> class(base2)
[1] “data.frame”
> base2
nom marie age csp
1 durand TRUE 40 artisan
2 dupont FALSE 28 ouvrier
3 dupond TRUE 41 ouvrier
4 martin TRUE 58 employé
5 pinault FALSE 35 artisan
6 vaillant FALSE 32 artisan
> table(base2$csp)
artisan employé ouvrier
3 1 2
> tapply(base2$age, base2$csp, mean)
artisan employé ouvrier
35.66667 58.00000 34.50000
> data(cars)
> 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
> hist(cars$dist)
> 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 ***
---