Vous êtes sur la page 1sur 71

Opérations de base, adaptation

et interfaces statistiques libres

Mémoire de stage IUT


Statistique et Traitement Informatique des Données
(STID)

Réalisé au sein de la société ARKESYS

Par Omran ALLATIF

Université Pierre-Mendès-France
Grenoble II

Septembre 2009

Maître de stage T. ANTHOUARD (Société Arkesys-Lyon)

Tuteur de stage J. P. GIRAUDIN (IUT STID-Grenoble)


TABLE DES MATIERES
1 Langage de programmation et logiciel de statistiques......................................................... 4
1.1 Sites et manuels importants ....................................................................................................................4
1.2 Manipulation des nombres et des matrices ..........................................................................................5
1.2.1 Opérations de base...............................................................................................................................................5
1.2.2 Manipulation ........................................................................................................................................................8
1.2.2.1 Suppression des lignes et des colonnes......................................................................................................8
1.2.2.2 Insertion des lignes et des colonnes ...........................................................................................................9
1.3 Manipulation des tables.........................................................................................................................10
1.3.1 Importation et exportation des tables ...............................................................................................................10
1.3.2 Manipulation ......................................................................................................................................................11
1.3.3 Recherche sélective et exemple de requête SQL dans une table....................................................................13
1.3.4 Conversion des objets dans R ...........................................................................................................................16
1.4 La recherche dans R ..............................................................................................................................16
1.5 Affichage graphique...............................................................................................................................19
1.6 Packages: quelques opérations.............................................................................................................23
2 Statistiques ............................................................................................................................. 25
2.1 Statistiques élémentaires sur R ............................................................................................................25
2.1.1 Statistiques descriptives ....................................................................................................................................25
2.1.2 Somme, moyenne, variance. .............................................................................................................................25
2.1.3 Analyse de la variance (Anova)........................................................................................................................26
2.1.3.1 Anova à 1 facteur ......................................................................................................................................26
2.1.3.2 Anova à 2 facteurs avec interaction .........................................................................................................29
2.1.4 Régression linéaire ............................................................................................................................................30
2.1.4.1 Régression linéaire simple ........................................................................................................................30
2.1.4.2 Régression linéaire multiple .....................................................................................................................31
2.1.5 Tests statistiques ................................................................................................................................................31
2.1.5.1 Test de corrélation .....................................................................................................................................31
2.1.5.2 Test et intervalle de confiance sur une proportion ..................................................................................32
2.1.5.3 Test et intervalle de confiance sur l'égalité de plusieurs proportions ....................................................34
2.1.5.4 Test de Student et intervalle de confiance sur une moyenne..................................................................34
2.1.5.5 Test de Student et intervalle de confiance sur l'égalité de deux moyennes ...........................................35
2.1.5.6 Test de Fisher exact...................................................................................................................................37
2.1.5.7 Test du Chi-deux .......................................................................................................................................37
2.1.5.8 Test de normalité (Shapiro-Wilk).............................................................................................................38
2.1.5.9 Test de Fisher pour la comparaison de deux variances...........................................................................39
2.1.5.10 Test de Bartlett sur l'homogénéité des variances...................................................................................39
2.1.6 Opérations sur les listes.....................................................................................................................................39
2.1.7 Lois de probabilité sous R (18 lois)..................................................................................................................40
2.2 Algorithmique .........................................................................................................................................41
2.2.1 Exemple de boucles...........................................................................................................................................41
2.2.2 Exemple de boîte de dialogue...........................................................................................................................42
2.3 Interfaces statistiques libres .................................................................................................................45
2.3.1 SciViews: ...........................................................................................................................................................45
2.3.1 R-Commander....................................................................................................................................................47
2.3.2 Tinn-R ................................................................................................................................................................49
2.3.3 JGR (Java GUI for R)........................................................................................................................................50
3 Adaptation .............................................................................................................................. 52
3.1 Adaptation de R Console.......................................................................................................................52
3.2 Création de fenêtres au démarrage de R............................................................................................56
4 Conclusion ............................................................................................................................. 59
Annexe I: Liste exhaustive des opérations offertes par R-Commander.......................................................62
Annexe II: Symboles des opérations mathématiques disponibles en R. ......................................................68

1/71
Résumé
Ce document est un rapport de stage IUT STID de 10 semaines, effectué au sein de
la société Arkesys, une société de formation en informatique et en statistiques pour les
professionnels. Le but du stage est l'élaboration d'un manuel qui permet aux stagiaires

d'Arkesys d'utiliser le logiciel de statistiques .

Ce rapport porte sur le logiciel .

Il explique la manipulation des nombres, des matrices et des tables pour un public

débutant. Il enseigne aussi la recherche des fonctions en vue de leur


programmation, l'affichage graphique des données et il fournit un aperçu sur
l'algorithmique sous ce logiciel. Nous pouvons y trouver par ailleurs les informations
essentielles sur les packages.

Ce rapport répertorie les opérations et les tests statistiques les plus courants et
pourvoit un exemple pour chaque opération et test. Il rend compte de 4 interfaces
statistiques en termes de leurs complexités et de leurs orientations, lesquelles sont libres
et disponibles sur Internet. Il explique comment adapter la R Console en ajoutant de
nouveaux boutons dans la barre de menu, comme il montre enfin comment créer des
fenêtres indépendantes de la R Console et comment leurs associer des fonctions
exécutables.

2/71
Introduction

Il s'agit dans ce document d'un rapport de stage effectué dans le cadre d'un IUT
STID-AS1 au sein de la société Arkesys,
http://www.arkesys.fr/
spécialisée dans la formation des professionnels aux outils informatiques et statistiques
basée à Lyon et à Saint-Etienne, Le stage a eu lieu à Lyon 7ème.
Ce rapport est le fruit d'un travail d'une courte durée, 10 semaines, du 01/06/09
au 07/08/09, mené sous la direction de Monsieur T. Anthouard, formateur en
statistiques.
Le motif de ce stage est la volonté de la section statistique de la société Arkesys
d'avoir quelques prises sur le logiciel R et de développer une compétence interne qui
commence par l'établissement d'un manuel liminaire répertoriant la majorité des
opérations et des techniques dont ses stagiaires ont besoin. En effet, R est devenu un
outil très présent dans le domaine des statistiques, notamment auprès des chercheurs et
des biostatisticiens, auquel une partie du public stagiaire fait référence, ainsi ignorer R
reviendrait à ignorer une fraction du métier.
Ce rapport constitue la première version de ce manuel.
Nous exposerons dans ce rapport, dans un premier temps, la mise en oeuvre de
quelques techniques visant la manipulation des nombres, des matrices et des tables
pour un public naïf en termes de statistiques et d'informatique, et qui voudrait avoir à sa
disposition un outil alliant simplicité et efficacité tel que R.
Dans un deuxième temps, nous rendrons compte des résultats de nos recherches
concernant les interfaces graphiques gratuites du logiciel R
http://cran.r-project.org/
dédiées aux calculs statistiques. Outre le fait qu'il soit gratuit, ce logiciel présente le
grand avantage d'avoir un code source ouvert, ce qui veut dire que l'on peut le modifier et
le redistribuer sans aucune contrainte. Ces deux derniers points intéressent
particulièrement la société Arkesys, parce qu'ils lui permettent d'adapter le logiciel aux
besoins de son public de stagiaires issu de milieux professionnels assez hétérogènes avec
des exigences, naturellement, très variées.
L'inconvénient de ces interfaces graphiques, qui ont souvent fait l'objet de longs
travaux scientifiques très sérieux (pour certaines ce sont des logiciels qui se greffent sur
R) est qu'elles sont mises à disposition sans aucune garantie. Ceci a pour effet de freiner
l'élan de ceux qui ne connaissent pas R et les statistiques, ce qui rend ces interfaces
pratiquement inaccessibles, notamment à ceux qui veulent s'en servir à titre
professionnel, et non seulement à titre personnel.
Ceci étant, la tâche qui m'a été accordée consiste en la recherche d'une interface
parmi les nombreuses qui sont disponibles, qui soit la mieux adaptée au public de
stagiaires d'Arkesys (pas très simple, pas très complexe non plus). Il s'agit aussi de
vérifier manuellement que l'interface choisi ne génère pas de résultats erronés pour les
opérations qu'elle réalise. Finalement on doit étudier la structure interne en vue de créer
plusieurs versions adaptées aux besoins spécifiques des stagiaires.

1 STID-AS: Statistique et Traitement Informatique des Données-Année Spéciale. Cet IUT (Institut Universitaire de
Technologie) était suivi à l'UPMF (Université Pierre Mendès France) à Grenoble.

3/71
Conventions:
• Je surligne en rouge les commandes en langage R, susceptibles d'être exécutées.
• En italique sont les sorties des exécutions (les résultats ou les messages).
• Les dièses désignent les commentaires. Une ligne précédée par un dièse ne peut
pas être exécutée par R. Je les introduis dans les programmes exécutables. Ces
programmes seront ainsi prêts à être copiés et collés dans un script tels qu'ils
sont et puis exécutés en guise de démonstration.
• Les adresses des pages Internet sont dans des lignes à part.

1 Langage de programmation et logiciel de


statistiques
R est un ensemble de programmes destinés aux calculs mathématiques, à la
manipulation des données ainsi qu'à leurs représentations graphiques. Ce logiciel est
connu pour ses capacités de traitements des données et de leur stockage. R est aussi un
ensemble d'opérateurs relatifs aux calculs matriciels. Malgré quelques différences
considérables entre le langage R et le langage S, ces 2 langages restent très proches, une
grande partie du code S peut être exécutée directement sur R. Tous deux sont conçus
pour permettre à l'utilisateur d'ajouter de nouvelles fonctionnalités en définissant de
nouveaux programmes. Des codes écrits en C, en C++ ou en Fortran peuvent être
exécutés aussi sous R. Donc R n'est pas un langage complètement nouveau, inventé
spécialement pour les opérations statistiques, c'est bien une extension et une continuité
de langages déjà présents et qui ont prouvé leur efficacité dans le passé. Une très grande
partie du système R est soutenue par des fonctions qui sont elles-mêmes écrites en
langage S, il peut être finalement considéré comme une des applications du langage S,
lequel a été développé aux Laboratoires Bell par R.Becker, J.Chambers et A.Wilks.

1.1 Sites et manuels importants


Site officiel du projet R (téléchargement, mailing liste, contribution):
http://www.r-project.org/
Wikipédia, pour l'émergence du projet, premiers auteurs, origine du nom R ainsi
que pour les liens que R entretient avec les autres langages:
http://en.wikipedia.org/wiki/R_(programming_language)
Un document important (en français) pour commencer l'usage de R:
http://cran.r-project.org/doc/contrib/Paradis-rdebuts_fr.pdf
Un glossaire (en anglais) très pratique qui répertorie seulement les fonctions les
plus courantes, avec une explication très concise, sans exemples, pour chacune de ces
fonctions:
http://cran.r-project.org/doc/contrib/Short-refcard.pdf
Pour un document détaillé (quelque 3000 pages en anglais) sur les fonctions et la
structure du logiciel R:
http://cran.r-project.org/doc/manuals/fullrefman.pdf
Introduction à la programmation en S:
http://cran.r-project.org/doc/contrib/Goulet_introduction_programmation_S.pdf

4/71
Une introduction à la programmation en R (en français), très pédagogique avec une
très agréable présentation faite par J. R. Lobry :
http://pbil.univ-lyon1.fr/R/cours/lang03.pdf

1.2 Manipulation des nombres et des


matrices

1.2.1 Opéra tions de ba se


Pour exécuter une opération R, on peut écrire les commandes soit directement dans
la R Console (la première fenêtre qui s'ouvre au démarrage de R) où l'on fait "Entrée" à la
fin de chaque commande pour l'exécuter, soit on les écrit dans un script
"Fichier=>Nouveau script" puis on les sélectionne (toutes ou une partie) et on les exécute
par "Ctrl+r" sous Windows et Pomme+Entrée sous Mac OS X. Le script peut être sauvé et
exécuté à nouveau plus tard.
Pour affecter la valeur 35 à la variable X
X<- 35
X est maintenant une variable qui vaut 35 qu'on peut manipuler en l'additionnant,
la soustrayant, la multipliant, etc., par une autre variable ou par un réel.
M<-3*X
M vaut 105.
P<-M*X
P vaut 3675.
Pour affecter un ensemble de valeurs à la variable X, le caractère "c" doit précéder
cet ensemble qui doit être saisi entre parenthèses, les valeurs doivent être séparées par
des virgules.
X<- c(5, 12, 14, 15, 18, 22, 31, 54, 42)
Si l'on veut considérer X comme un vecteur, c'est-à-dire que l'on tient compte de la
position de la valeur selon sa ligne, on fait précéder cet ensemble de valeur par
l'expression "matrix"
X<- matrix(c(5, 12, 14, 15, 18, 22, 31, 54, 42))
X est maintenant un vecteur de 9 lignes et d'une colonne. Les contraintes
matricielles s'appliquent alors, c'est-à-dire qu'on ne peut pas multiplier X par n'importe
quel vecteur, il faut que les dimensions soient adéquates.
Saisir des données : pour déclarer une matrice il faut procéder comme suit :
Nom de la matrice: pas de tiret dans le nom de la matrice, seulement des points et
des tirets bas (underscores) sont autorisés, on note aussi que R est sensible à la casse
(Minuscule ≠ Majuscule).
Le nom de la matrice doit être suivi du signe "<-"2 pour désigner une affectation
(différente de l'égalité).
Il faut écrire ensuite "matrix", ouvrir des parenthèses écrire "c" pour signifier que
les éléments font partie d'un même ensemble, puis ouvrir de nouveau des parenthèses et
saisir les valeurs en les séparant par des virgules ",". Le point "." est utilisé comme une
virgule décimale. Une fois la saisie terminée, il faut fermer les deuxièmes parenthèses

2
Dans ce document, les guillemets entourant un signe ne font pas partie du signe en question, ce sont de simples
délimitateurs.

5/71
suivies d'une virgule",". Il faut préciser ensuite le nombre de lignes "nrow=" et le nombre
de colonnes "ncol=" et fermer les premières parenthèses.
Exemple:
M.K<- matrix(c(12,14,15,52,14,45,47,48,98,62,24,14.45,15,13.25,22), nrow=3,
ncol=5)
Nous avons maintenant une matrice qui s'appelle M.K formée de 3 lignes et de 5
colonnes.
R considère que les valeurs saisies constituent une seule colonne par défaut. Si l'on
veut préciser le nombre des lignes et celui des colonnes il faudra l'écrire explicitement. Le
nombre de lignes "nrow=" et le nombre de colonnes "ncol=" comme il faut préciser si les
valeurs sont rentrées par ligne "byrow =TRUE" comme dans l'exemple A ci-dessous, ou
par colonne (par défaut), exemple B ci-dessous.
Exemple A:
X<-matrix(c(12,14,15,52,14,45,47,48,98,62,24,14.45,15,13.25,22), nrow=3, ncol=5,
byrow=TRUE)

12 14.00 15 52.00 14
45 47.00 48 98.00 62
24 14.45 15 13.25 22

Exemple B:
X<-matrix(c(12,14,15,52,14,45,47,48,98,62,24,14.45,15,13.25,22), nrow=3, ncol=5)

12 52 47 62.00 15.00
14 14 48 24.00 13.25
15 45 98 14.45 22.00

Calcul matriciel sur R:


L’addition d’un réel x avec les éléments d'une matrice :
x+A
L’addition de 2 matrices du même format (terme à terme) :
A+B
La soustraction d'un réel aux éléments d'une matrice :
A-x
La soustraction de 2 matrices du même format (terme à terme) :
A-B
La multiplication d'une matrice par un réel :
x*A
La multiplication terme à terme de même format:
A*B
La multiplication matricielle (nb de col. de A = nb de lignes de B obligatoire) :
A% *%B
La division de deux matrices de même format (terme à terme) :
A/B
L’inverse matriciel :

6/71
solve(B)
La division matricielle :
A%*%solve(B)
Déterminant:
det(A)
Trace:
sum(diag(A))
Transposée:
t(A)
Calcul des valeurs propres et vecteurs propres:
eigen(A)

R est destiné aussi aux calculs mathématiques très fréquents, à titre d'exemple: la
résolution d'un système d'équations, le calcul de l'intégrale, le calcul du minimum ou du
maximum d'une fonction. Application:
Exemple de résolution d'un système d'équations à trois inconnues sur R.
2x + y - 3z = 4
x + -2y + z = -3
x + 2y + z = 9

A<-matrix(c(2,1,1,1,-2,2,-3,1,1), nrow=3)
2 1 -3
1 -2 1
1 2 1

B<-matrix(c(4,-3,9))
4
-3
9

X<-solve(A)%*%B
2
3
1
x = 2, y = 3 et z = 1.

Intégrale
X<-seq(1,6, by=0.5)
fon<-function(X) {2*X+4}
int<-integrate(fon, lower=2,upper=4)$value
int
R donne 20 comme résultat.
L’optimisation d’une fonction consiste à trouver son maximum ou son minimum:
optimize
optimize(f=function(x){cos(x^2)},lower=0,upper=2)$minimum

7/71
1.2.2 Manipulati on
1.2.2.1 Suppression des lignes et des colonnes
(Instructions valables pour les tables également).
Soit la matrice W définie comme suit:

1 9 5 8 5
5 6 2 9 4
4 5 1 6 1
7 4 4 3 4
8 7 7 2 7

W<-W[-c(2,3),]
Cette commande se traduit comme suit: supprimer de la matrice W la deuxième et
la troisième lignes de toutes les colonnes.

1 9 5 8 5
7 4 4 3 4
8 7 7 2 7

W<-W[,-c(2,3)]
Cette commande se traduit comme suit: supprimer de la matrice W la deuxième et
la troisième colonnes de toutes les lignes.

1 8 5
7 3 4
8 2 7
Nous pouvons supprimer des lignes et des colonnes en même temps
W<-W[-c(2,3),-c(2,3)]
Cette commande se traduit comme suit: supprimer de la matrice W la deuxième et
la troisième lignes de toutes les colonnes, et la deuxième et la troisième colonnes de
toutes les lignes.

8/71
1.2.2.2 Insertion des lignes et des colonnes
Ajouter des lignes et des colonnes dans une matrice nécessite le chargement du
package micEcon, soit require(micEcon).
Soit X la matrice suivante:

2 9 1 5 6
5 5 2 1 3
4 4 1 2 2
7 7 4 4 1
8 5 5 5 4
9 1 7 6 5
6 4 8 9 7
5 7 9 8 8
4 8 6 7 9
1 5 3 4 5

X<-insertRow(X,5,X[10,]*100)
Cette commande se traduit comme suit: insérer une ligne dans la matrice X à la
cinquième position, les valeurs sont celles de la ligne 10 de X multipliées par 100.

2 9 1 5 6
5 5 2 1 3
4 4 1 2 2
7 7 4 4 1
100 500 300 400 500
8 5 5 5 4
9 1 7 6 5
6 4 8 9 7
5 7 9 8 8
4 8 6 7 9
1 5 3 4 5

X<-insertCol(X,6,X[,5]*100)
Cette commande se traduit comme suit: insérer une colonne dans la matrice X à la
sixième position, les valeurs sont celles de la colonne 5 de X multipliées par 100.

2 9 1 5 6 600
5 5 2 1 3 300
4 4 1 2 2 200
7 7 4 4 1 100
100 500 300 400 500 50000
8 5 5 5 4 400
9 1 7 6 5 500
6 4 8 9 7 700
5 7 9 8 8 800
4 8 6 7 9 900
1 5 3 4 5 500

9/71
1.3 Manipulation des tables

1.3.1 Impor tation et exporta tion des tabl es


Lecture des tables: pour ouvrir la table nommée "neige", nous utilisons la fonction
read.table() qui dispose de 21 paramètres, nous citons ci-dessous les plus fréquemment
utilisés, à savoir: le chemin (seul paramètre obligatoire), présence ou absence de
l'intitulé, le type du délimitateur (espace, étoile, etc) et le type de la virgule décimale. Si
"header=T" les variables peuvent alors être appelées par leurs noms, sinon on les appelle
par leurs positions.
neige <-read.table("CheminDeLaTable", header=FALSE, sep=",", dec=".")
Exemple:
neige <-read.table("D:/Mes documents/ARKESYS_STAGE_STATS/moydiff.txt")

Cette fonction ne peut ouvrir que des formats compatibles avec R. Par exemple pour
importer une table d'un format quelconque, il faut d'abord la convertir au format ".txt"
puis faire read.table("CheminDeLaTable").
Pour exporter une table depuis R vers un format ".txt" :
write.table(Dataset, "C:/Documents and Settings/PC/Bureau/Dataset.txt", sep=" ",
col.names=TRUE, row.names=TRUE, quote=TRUE, na="NA")
Un autre format couramment utilisé sous R pour importer des feuilles Excel, est le
format ".csv". Donc on peut enregistrer une feuille de calcul Excel sous le format ".csv"
avant de l'ouvrir sous R avec la fonction
read.csv ("fichier.csv")

On peut importer une feuille Excel ".xls" directement, mais il faut choisir la fonction
appropriée qui est read.xls("CheminDeLaFeuille"). Ici les arguments sont définis par
défaut, sauf le chemin qui est le seul argument obligatoire:
read.xls("CheminDeLaFeuille", colNames = TRUE, sheet = 1, type = "data.frame", from =
1, rowNames = NA, colClasses = NA, checkNames = TRUE, dateTimeAs = "numeric",
stringsAsFactors = default.stringsAsFactors()). Cette fonction n'existe pas dans les
packages installés par défaut lors de l'installation de R, elle existe dans le package
xlsReadWrite qu'on doit installer, et puis charger avec require(xlsReadWrite).
Pour exporter des données depuis R sous format Excel, il faut utiliser la fonction
write.xls() les données peuvent être data.frame, matrice/vecteur de type entier, réel,
logique ou caractère.
Exemple où l'on exporte la data.frame TaillePoids dans le répertoire
ARKESYS_STAGE_STATS et on lui donne le nom voiron.xls. Les autres arguments sont
donnés par défaut: colNames = TRUE: la première ligne contient les intitulés des
colonnes. sheet = 1: on place les données exportées dans la première feuille du fichier
voiron.xls. from =1: on commence l'écriture dans la feuille à partir de la première ligne.
rowNames = NA: signale que les données exportées n'ont pas de colonne dédiée aux
noms des lignes, mais elles peuvent l'avoir dans le document où elles seront exportées.
write.xls(TaillePoids,"D:\\Mesdocuments\\ARKESYS_STAGE_STATS\\voiron.xls",
colNames = TRUE, sheet = 1, from = 1, rowNames = NA)

Pour éditer simplement sans vouloir changer les données.


edit (table.txt)

10/71
Pour éditer dans le but de changer les données.
fix(table.txt)

1.3.2 Manipulati on
Renommer des lignes et des colonnes:
On nomme avec la commande ci-dessous les lignes 2,3 et 4 de la table "neige"
respectivement "baba", "tata" et "loulou".
rownames(neige)[c(2,3,4)]<-c("baba","tata","loulou")

NB: dans une table sous R, le nom d'une ligne est unique et ne peut pas se
répéter!

On nomme avec la commande ci-dessous les colonnes 2,3 et 4 de la table "neige"


respectivement "foufou", "lala" et "mala".
colnames(neige)[c(2,3,4)]<-c("foufou","lala","mala")

Exemple: renommer des lignes par boucle.


TaillePoids<-
read.xls("D:\\Mesdocuments\\ARKESYS_STAGE_STATS\\TaillePoids.xls")
individus<-c("Jean", "Pierre","Rachida", "Mat", "Marie", "Chloé", "Martin")
for (i in 1:length(individus)){
rownames(TaillePoids)[i]<- individus[i]
}
Suppression par nom: si tabb est une table qui contient la colonne TOTO,
tabb$TOTO <- NULL
supprime la colonne TOTO de la table tabb.

Suppression par position:


tabb<-tabb[-c(2,3),]
La commande ci-dessus supprime de la table tabb la deuxième et la troisième
lignes.

tabb<-tabb[,-c(2,3)]
La commande ci-dessus supprime de la table tabb la deuxième et la troisième
colonnes.

Création de nouvelles colonnes par nom dans une table à partir des colonnes
existantes.

11/71
Si M était une table comme ci-dessous:
Groupe1 Groupe2 Groupe3
5.621 3.847 3.513
1.124 2.773 5.737
4.377 3.930 7.025
2.296 2.621 2.039
2.570 4.335 3.190
5.406 5.785 4.347
Alors la commande
M$toto<-M$Groupe1*2
crée une nouvelle colonne nommée "toto" dont les valeurs valent 2 fois les valeurs
de la colonne "Groupe1".
M devient:
Groupe1 Groupe2 Groupe3 toto
5.621 3.847 3.513 11.242
1.124 2.773 5.737 2.248
4.377 3.930 7.025 8.754
2.296 2.621 2.039 4.592
2.570 4.335 3.190 5.140
5.406 5.785 4.347 10.812
Aucun des noms des colonnes ne doit comporter d'espaces, si c'est le cas, il faut
faire par position:
M$toto<-M[,1]*2

Création de nouvelles colonnes par position dans une table à partir des colonnes
existantes.
On crée une quatrième colonne à partir de la première et de la troisième:
ME1[,4]<-ME1[,1]+100*ME1[,3]
ME1
Groupe1 Groupe2 Groupe3 V4
5.621 3.847 3.513 356.921
1.124 2.773 5.737 574.824
443.321 396.847 706.013 71044.621
2.296 2.621 2.039 206.196
2.570 4.335 3.190 321.570
5.406 5.785 4.347 440.106
14.375 11.707 17.563 1770.675
On peut en créer autant qu'on veut, elles seront appelées V4, V5, etc., selon la
position de la colonne qu'elles occupent.

Mettre une partie de la table dans une autre table


M2<-drop(M[,c(2,3)])
Cette commande crée une table M2 dans laquelle on met les colonnes 2 et 3 de la
table M.
M2
Groupe2 Groupe3
3.847 3.513
2.773 5.737
3.930 7.025
2.621 2.039

12/71
4.335 3.190
5.785 4.347

Remplacement des lignes et des colonnes:


Soit la table ME1:
Groupe1 Groupe2 Groupe3
5.621 3.847 3.513
1.124 2.773 5.737
4.377 3.930 7.025
2.296 2.621 2.039
2.570 4.335 3.190
5.406 5.785 4.347
14.375 11.707 17.563

ME1[3,]<-ME1[1,]+100*ME1[3,]
Cette commande remplace la ligne 3 de la table ME1 par une ligne qui est le
résultat de la multiplication de la ligne 1 par 100 fois la ligne 3 de la même table. Ce
procédé est valable pour le remplacement des colonnes.
ME1 devient:
Groupe1 Groupe2 Groupe3
5.621 3.847 3.513
1.124 2.773 5.737
443.321 396.847 706.013
2.296 2.621 2.039
2.570 4.335 3.190
5.406 5.785 4.347
14.375 11.707 17.563

1.3.3 Recherche sél ecti ve et exemple de


requête SQL dans une tabl e
Soit la table TaillePoids que nous importons sous R:
TP<-read.xls("D:\\Mes documents\\ARKESYS_STAGE_STATS\\TaillePoids.xls")
Nous nous assurons que la table était bien importée en demandant les noms des
colonnes:
colnames(TP)
"Groupe" "Sexe" "Taille" "Poids" "Note"
Pour afficher le contenu de la table, on écrit tout simplement le nom de la table
dans la CLI (la fenêtre de la R Console): TP et on fait Entrée, on a le résultat ci-dessous:

13/71
Groupe Sexe Taille Poids Note
G1 F 172.0274 59.68077 12.301952
G1 G 168.0728 71.53185 5.981991
G1 G 168.2383 73.10149 5.929544
G1 G 179.2309 76.75592 5.617884
G1 F 179.6412 64.40595 6.305926
G1 F 173.0091 69.95462 16.222324
G1 F 174.0569 69.61605 10.750165
G2 F 158.4863 66.24578 9.017682
G2 G 164.8338 62.47947 15.233870
G2 G 159.6777 64.24898 11.042394
G2 F 181.4587 65.82208 14.614237
G2 G 175.2155 65.70723 15.130763
G2 G 174.7247 75.00289 14.436124
G2 G 168.7716 80.18736 14.399006
G3 G 177.8929 69.29596 15.086079
G3 G 180.2972 79.95882 7.243951
G3 F 182.7809 62.53579 12.226559
G3 F 175.5737 93.30787 9.673261
G3 F 171.8510 75.26463 8.323601
G3 G 189.1324 86.43452 9.154828
G3 F 177.8063 82.78912 8.126908
G3 F 154.1723 82.22693 14.955646
attach(TP)
La commande ci-dessus permet de traiter les colonnes de la table comme des
variables à part entière, c'est-à-dire qu'après avoir fait attach(TP), si l'on tape Taille dans
la CLI, nous aurons les valeurs de cette colonne, si l'on fait mean(Taille), on obtient
directement la moyenne de la colonne Taille, et ainsi de suite.
Nous voulons maintenant obtenir la moyenne de la taille de tous les individus qui
appartiennent aux Groupes G1 et G2, qui ont une Note inférieure ou égale à 10 et qui
ont le Poids strictement inférieur à 80.
Pour satisfaire cette requête, soit nous faisons une boucle qui parcourt la table
comme ci-dessous:

N<-0
s<-0
for (i in 1: length(Groupe)){
if ((Groupe[i] =="G1"|Groupe[i] == "G2")& (Note[i] <= 10) & (Poids[i]<80)){
#la barre verticale signifie "ou".
N<-N+1
s<-s+Taille[i]}
moy<-s/N

14/71
next
}

Soit nous y arrivons par une syntaxe R comme suit:


SelTaille<-(Taille[(Groupe =="G1"|Groupe == "G2")& (Note <= 10) & (Poids<80)])
mean(SelTaille)
Nous pouvons avoir la moyenne, ou autre paramètre (somme, variance , etc),
directement, sans afficher le résultat d'une sélection:
mean(Taille[(Groupe =="G1"|Groupe == "G2")& (Note <= 10) & (Poids<80)])
Nous pouvons extraire avec une ou plusieurs conditions une partie d'une table
existante et la mettre dans une nouvelle table.
TP2<-TP[Groupe=="G1"|Groupe=="G2",]
TP2 contient uniquement les individus appartenant aux groupes G1 et G2.
Nous pouvons aussi extraire toute une partie de la table satisfaisant une ou plusieurs
conditions:
bb<-subset(TP,(Groupe == "G1"|Groupe =="G3") & (Note>10)&(Poids>50) & (Sexe ==
"F"))
bb devient:
Groupe Sexe Taille Poids Note
G1 F 172.0274 59.68077 12.30195
G1 F 173.0091 69.95462 16.22232
G1 F 174.0569 69.61605 10.75016
G3 F 182.7809 62.53579 12.22656
G3 F 154.1723 82.22693 14.95565

Exemple de requête SQL sur R: La syntaxe R peut se montrer insuffisante pour des
requêtes assez complexes, il vaut mieux travailler dans ce cas avec des packages conçus
pour les recherches dans les bases de données. En effet, les packages destinés à la
gestion des bases de données, comme le package "sqldf", disposent de fonctions et de
programme plus élaborés que ceux qu'on trouve dans le package "base" de R.
Après avoir installé le package "sqldf", install.packages("sqldf", dep =T), il faut le
charger require(sqldf)
Exemple d'une requête où nous obtenons la taille et le groupe des personnes
appartenant soit au groupe G1 soit au groupe G2 étant de sexe féminin et ayant une
note supérieure à 10 et un poids supérieur à 60, cette requête peut s'écrire comme suit:
sqldf("select Taille, Groupe from TP where (Groupe = 'G1' or Groupe = 'G2') and Sexe = 'F'
and Note >10 and Poids >60"),
elle donnera le résultat suivant:
Taille Groupe
173.0091 G1
174.0569 G1
181.4587 G2
Des opérateurs comme: *, Limit, like, in/between, order by, group by, natural join,
etc sont possibles pour affiner la recherche et atteindre une qualité professionnelle dans
la gestion des bases de données. Nous ne détaillerons pas davantage cet aspect dans ce
rapport, notre objectif étant les interfaces statistiques gratuites sur R.

15/71
1.3.4 Conversion des obj ets dans R

La fonction mode permet de savoir quel est le type de l'objet qu'on manipule:
mode(X)
"numeric"
Nous pouvons aussi poser des questions pour savoir quelle est la nature de l'objet:
is.matrix(X) # est-ce que X est une matrice? réponse logique (Vrai/Faux)
TRUE
On converti ici la matrice en liste, les objets n'aurons plus les mêmes propriétés et
ne seront pas manipulés de la même manière.
MaListe<-as.list(X) # MaListe est un objet R qui récupère les données de la matrice
X sous forme de liste. Pour s'en assurer:
mode(MaListe)
"list"

1.4 La recherche dans R


Cette partie de notre rapport est fondamentale, parce que personne ne réussira à
retenir toutes les fonctions R par cœur, et par conséquent le recours à la recherche est
indispensable à tous les niveaux, pour les novices comme pour les experts.
On va distinguer trois niveaux de connaissance de la fonction qu'on cherche:
(1) On ne connaît pas le nom de la fonction, mais on soupçonne un nom, ou on
connaît à coup sûr une partie du nom (ne serait-ce que 3 lettres), donc c'est une
recherche orthographique simple:

apropos(what, where = FALSE, ignore.case = TRUE, mode = "any")

what: c'est le mot qu'on cherche, il faut le mettre entre guillemets " ".
c'est le seul paramètre obligatoire, les autres sont spécifiés par défaut comme ci-
dessus.
where: renvoie le numéro de ligne où le mot se trouve dans le package.
ignore.case: sensible ou non à la casse (minuscule/majuscule).
Mode: pour le type ou la nature de l'objet recherché:
logical, integer, double, complex, raw, character, list,
expression, name, symbol et function. Cette liste n'est pas exhaustive.
Exemple: apropos("read.tab")
"read.table" "read.table.url"

(2) On connaît un mot, et on cherche des alias, des concepts et des titres
correspondant au mot en question, la correspondance est floue: c'est avec deux point
d'interrogation qui se succèdent. (Note: pas d'accent dans les noms des mots recherchés!
).
??MotRecherché

16/71
Ou
help.search("MotRecherché")
Dans la deuxième nous pouvons spécifier une douzaine de paramètres, à l'instar du
(1). En fait ??MotRecherché est la même chose que Help.search("MotRecherché") ayant
les paramètres par défaut, pour voir comment ces paramètres sont préprogrammés il
faut faire: help("help.search").

3) Lorsqu'on est sûr de la présence d'un mot et de son orthographe et qu'on veut
savoir de quel package il provient (Attention à la casse!):
find("MotRecherché")

4) Pour avoir les détails sur une fonction R, comment elle se programme et quels
sont ses paramètres:
help("MotRecherché")
pour voir les 9 paramètres de la fonction help, faire help("help")

5) Une fonction qui consiste à chercher sur Internet et dont l'utilité est vraiment
considérable, est :
RSiteSearch("MotRecherché")

Cette fonction envoie la requête vers le site


http://search.r-project.org
Elle cherche dans les fichiers d'aide à la programmation sous R, dans les manuels
ainsi que dans les archives des listes mailing des usagers de R.
Cette dernière fonction n'est pas la plus rapide pour arriver à l'information
recherchée, elle s'avérera en contrepartie indispensable quand on veut réaliser une tâche
dont on n'a pas la moindre idée, donc quand on ne sait pas par où commencer… Parce
que les 4 précédentes cherchent dans ce qui existe, c'est-à-dire que si l'on cherche une
fonction qui n'est pas dans un package déjà installé, l'aide est infructueuse, et on est
bloqué.
Si l'on veut, par exemple, créer une fenêtre, on peut écrire create window, créer une
interface graphique create graphical interface et se laisser guider par les propositions
offertes par ce site.

Avec ces 5 instructions ci-dessus nous pouvons partir de très peu d'informations
sur une fonction R pour parvenir à obtenir tous les détails possibles la concernant et
l'exploiter correctement selon nos besoins.

Recherche de variables: pour savoir quelles sont les variables qui ont été créées
durant une session (ou importées d'autres sessions), il faut faire ls().
Pour restreindre la liste aux variables dont le nom contient la lettre "m" par
exemple:
ls(pat = "m")
Pour la liste des variables dont le nom commence par la lettre "m":
ls(pat = "^m")

17/71
Pour chercher dans un texte
grep("ChaîneRecherchée", TexteOùChercher, ignore.case = FALSE)
"ignore.case": sensible ou non à la casse.
Pour avoir le nombre de lignes ainsi que la longueur de la ligne la plus longue du
texte "d"
stringDims(d)
stringDims(d)$height # pour avoir le nombre de lignes du texte "d".
stringDims(d)$width # pour avoir la longueur de la ligne la plus longue du texte "d"

Par position: soit X une matrice de dimension n-p:


grep(0.5,X)
cherche les occurrences de la valeur 0.5 et donne leurs rangs dans la matrice en
comptant par ligne (c'est-à-dire qu'il parcourt les valeurs de la première ligne, elle passe
à la deuxième, à la troisième, et ainsi de suite).

18/71
1.5 Affichage graphique
X<-seq(-20,20,by=1)
La commande ci-dessus crée un vecteur allant de -20 à 20 par pas de 1.
Y<-2*X^2+12*X+8
plot(X,Y)
Cette dernière commande permet l'affichage du graphique ci-dessous.

Si l'on veut superposer d'autres éléments sur le graphique, il faudra faire "lines"
pour ajouter des lignes ou "points" pour ajouter des points.
Exemple:
Z<- -4*X+4
T<- -4*X+2
lines(X,Z, col = "blue", lwd = 8)
points(X,T,"l", col = "red", lwd = 8)

19/71
La fonction "abline" permet d'afficher des lignes ou du texte sur le graphique. Les
lignes sont affichées par des équations affines, où "b" est le coefficient directeur et "a" est
l'ordonnée à l'origine.
Exemple
abline(b=-4, a=22,h=500,v=0)
la commande ci-dessus dessine une droite d'équation Y=4*X+22, "h" une droite
horizontale où Y = 500 et "v" est une droite verticale où X= 0.

20/71
Superposition de la courbe théorique sur un histogramme de fréquences.
EXEMPLE:
x<-rnorm(1000) #génère 1000 valeurs distribuées selon la loi normale, moyenne = 0
#et variance =1, par défaut.
y<-density(x)
hist(x, proba =T, main = "Distribution selon la loi normale",
xlab = "Valeur de x", ylab = "densité en fonction de x")
Pour voir comment R a réparti en classes les valeurs d'une variable, il faut faire
"table(variable)"
table(x)

lines(y, col ="red") # génère la courbe rouge.


z<-seq(min(x),max(x),0.01)
lines(z,dnorm(z,0,1),lty=2,"b", col = "blue") #superpose densité théorique, la grosse
cloche bleue.

21/71
Figure 1. Superposition de l'histogramme de fréquences, courbe de densité et courbe de distribution théorique.

Pour faire des affichages interactifs il faut installer et charger le package "iplots".
On peut utiliser alors la fonction "iplot" à la place de "plot", la représentation graphique
des données apparait alors dans une interface munie d'un nombre considérable de
fonctionnalités relatives à la gestion des graphiques. Pour ajouter de nouvelles courbes
sur un même graphique c'est l'instruction "ilines". Il faut bien faire attention au fait que
les arguments de "plot" et de "iplot" ne sont pas les mêmes.
Exemple avec "iplot":
X<-seq(-20,20,by=1)
Y<-2*X^2+12*X+8
iplot(X,Y)
Z<--4*X+80
ilines(X,Z)

22/71
Figure 2. Exemple de graphique interactif sous R.

Pour en savoir plus sur l'affichage graphique sous R, il faut regarder les quelque 81
fonctions que contient le package "graphics", il faut le charger, require(graphics) et
l'ouvrir ls(package:graphics) pour avoir accès aux noms des fonctions qu'il offre. Ce sont
des fonctions intéressantes et très élaborées pour répondre à des exigences très
pointues. Nous n'avons malheureusement pas eu le temps pendant ce stage de les
explorer suffisamment pour les présenter dans ce rapport.

1.6 Packages: quelques opérations


Quand on télécharge R, il y a 25 packages à peu près qui sont installés par défaut,
il faut aller chercher les autres sur le site:
http://CRAN.R-project.org
Un package est ensemble de variables, de fonctions et de procédures qui sont
contenues dans un ou plusieurs programmes qui communiquent entre eux pour réaliser
un ensemble de tâches bien défini. D’après mon expérience personnelle (bien limitée), je
conseille pour télécharger le package "PackageLambda" d'utiliser
install.packages("PackageLambda", dep =TRUE) depuis la R Console. Parce que cette
manipulation permet de télécharger les autres packages dont le package
"PackageLambda" a besoin pour fonctionner correctement.

Nous avons pu dénombrer 2094 packages disponibles au jour d'aujourd'hui


(24/08/2009), et leur nombre est en constante augmentation. Pour la liste exhaustive

23/71
des packages, que nous avons volontairement évité d'introduire dans les annexes de ce
rapport en raison de sa taille (40 pages), il faut se rendre sur la page:
http://search.r-project.org/packages.html
Voilà les opérations les plus fréquentes que nous sommes amenés à faire avec les
packages:
library() : pour voir les packages déjà installés.
require(tcltk) : charge le package tcltk, même chose que library(tcltk)
ls(package:tcltk): affiche les fonctions du package tcltk (le package doit être chargé)
library(help=tcltk) : documentation sur le package tcltk (le package doit être
installé, mais pas forcément chargé)
search() liste les packages dont le package 'base' a besoin.

Chargement de packages
Nous rappelons ici qu'un package installé n'est pas synonyme de package chargé.
Pour charger un package, c'est la fonction require(NomPackage). Si nous savons que
nous allons avoir besoin d'un certain nombre de packages qui ne sont pas chargés par
défaut, alors il faut introduire les fonctions concernées dans le "Rprofile.site" pour éviter
de les introduire manuellement depuis la CLI après chaque démarrage. Pour notre travail
pendant le stage nous avions par exemple besoin des packages ci-dessous:
require(tkrplot)
require(tcltk)
require(tcltk2)
require(xlsReadWrite)

Ces packages deviennent alors accessibles, on peut voir leurs contenus, par
exemple.
ls(package:xlsReadWrite)
et faire appel à leurs fonctions dès le démarrage.

installed.packages() permet d'avoir des détails sur les packages installés, library()
permet de les voir tout simplement.

24/71
2 Statistiques

2.1 Statistiques élémentaires sur R

2.1.1 Sta tistiques descriptives


Pour avoir les statistiques descriptives sur la table "lambda", c'est la fonction
summary(lambda).
Cette fonction fournit les éléments les plus classiques des statistiques descriptives.
Concernant les variables quantitatives elle donne: minimum et maximum, premier,
deuxième (médiane) et troisième quantiles ainsi que la moyenne. Quant aux variables
qualitatives elle donne les modalités de chaque variable ainsi que l'effectif de chaque
modalité. Cette fonction permet également d'avoir des statistiques descriptives sur une
ou plusieurs variables (ou individus) de la table. Exemple: soit la table TP importée en
1.3.3. si nous voulons avoir les statistiques descriptives sur les variables "Groupe" et
"Taille", soit nous procédons par nom: summary(TP[,c("Groupe","Taille")]), soit par
position: summary(TP[,c(1,3)])

2.1.2 Somme, moyenne, variance.


Soit la matrice X de n lignes et de p colonnes:
Pour obtenir la moyenne de chacune des variables (en colonne):
apply(X, 2, mean)
Pour obtenir la moyenne de chacun des individus (en lignes):
apply(X, 1, mean)
Pour la somme, on remplace "mean" par "sum", pour la variance c'est "var", et ainsi
de suite pour les autres fonctions, "mode", "median", etc.
Si nous ne voulons obtenir la moyenne que pour un certain nombre de variables
d'un certain nombre d'individus, nous pouvons le spécifier dans la commande "apply"
Exemple:
apply(X[c(2,3,4), c(2,3)],2, mean)
Cette commande obtient la moyenne pour les individus 2, 3 et 4 des variables 2 et 3
de la matrice/table X. Pour dire de toutes les lignes, il ne faut rien noter dans l'endroit
où les lignes à considérer sont spécifiées. Idem pour les colonnes.
Exemple:
apply(X[,c(2,3)],2, mean)
Cette commande obtient la moyenne pour tous les individus des variables 2 et 3 de
la matrice X.
Si la matrice était importée en tant que table par la fonction
read.table()
alors la moyenne est donnée pour chaque composante (ligne ou colonne) à part.
Exemple:
Tab<-read.table("NewTab.txt")
mean(NewTab)

25/71
Cette dernière commande permet d'avoir la moyenne de chacune des colonnes.
mean(NewTab[,c(2,3)])
Si NewTab était définie comme une matrice, alors
mean(NewTab)
Donne la moyenne totale, de toutes les colonnes.

Si l'on souhaitait toutefois obtenir la moyenne pour une variable, 2 variables, …, ou


toutes les variables ensemble:
mean(X[,2,3])
L'instruction ci-dessus permet d'obtenir la moyenne sur la deuxième et troisième
variables (ensemble) uniquement de tous les individus. Nous pouvons aussi restreindre
le nombre d'individus concernés par la même méthode.

Moyenne pondérée: On calcule ici la moyenne pondérée de n variables dans une


table, cette manipulation est intéressante lorsque nos individus (en ligne) n'ont pas tous
le même poids et que nous voudrions rendre compte de cette différence relative à leurs
rôles respectifs dans le système.
Soit X une matrice de n lignes (individus) et p colonnes (variables).
Pour obtenir la moyenne pondérée des variables de X, il faut créer au préalable une
matrice qui rende compte des poids des individus.
La matrice des poids PD est une matrice diagonale d'ordre n (le nombre des
individus dans X), si les individus ont un poids identique, les valeurs de la diagonale
sont toutes = 1/n.
n<-nrow(X)
PD <- diag(1/n, n)
Pour la pondération:
POND<-PD%*%X
Et pour effectuer la somme des valeurs pondérées il faut créer une matrice de 1
ligne et de n colonnes.
SOM<-rep(1,n)
Et finalement
MOY<-SOM%*%POND

2.1.3 Analyse de la varianc e (Anova)

2.1.3.1 Anova à 1 facteur

Soit la table TaillePoids que nous importons sous R:


TP<-read.xls("D:\\Mes documents\\ARKESYS_STAGE_STATS\\TaillePoids.xls")
Pour voir le nombre de lignes et de colonnes de cette table: dim(TP). Cette table a 22
observations et 4 variables: Groupe, Sexe, Taille, Poids et Note.

26/71
Groupe Sexe Taille Poids Note
G1 F 172,0 59,7 12,3
G1 G 168,1 71,5 6,0
G1 G 168,2 73,1 5,9
G1 G 179,2 76,8 5,6
G1 F 179,6 64,4 6,3
G1 F 173,0 70,0 16,2
G1 F 174,1 69,6 10,8
G2 F 158,5 66,2 9,0
G2 G 164,8 62,5 15,2
G2 G 159,7 64,2 11,0
G2 F 181,5 65,8 14,6
G2 G 175,2 65,7 15,1
G2 G 174,7 75,0 14,4
G2 G 168,8 80,2 14,4
G3 G 177,9 69,3 15,1
G3 G 180,3 80,0 7,2
G3 F 182,8 62,5 12,2
G3 F 175,6 93,3 9,7
G3 F 171,9 75,3 8,3
G3 G 189,1 86,4 9,2
G3 F 177,8 82,8 8,1
G3 F 154,2 82,2 15,0
La table TaillePoids

La variable Groupe contient trois groupes d'individus: G1, G2 et G3, on peut


imaginer que ces groupes représentent des individus vivant en ville, à la campagne et en
montagne respectivement, (ou tout autre scenario). Si nous voulons maintenant savoir si
le Poids est différent selon le lieu de vie, nous serons amenés à effectuer une analyse de
la variance pour tester l'hypothèse H0: les moyennes des poids des personnes vivant en
ville, à la campagne et en montagne sont égales entre elles Vs. H1: au moins deux
moyennes parmi les trois sont différentes entre elles.
R présente l'avantage de la simplicité concernant ce type d'opération, trois lignes de
syntaxes suffisent:
attach(TP). Cette commande permet d'avoir un accès direct aux variables de la
table.
MonAnova<-aov(Poids~Groupe). Toujours dans cet ordre: on teste si la variable
quantitative est différente selon les modalités de la variable qualitative.
summary(MonAnova)
R affiche alors la table d'analyse de la variance ci-dessous:
Df Sum Sq Mean Sq F value Pr(>F)
Groupe 2 517.95 258.97 4.4323 0.02631 *
Residuals 19 1110.14 58.43
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Dans la première ligne nous avons: Df ("degree of freedom"): degrés de liberté.


Sum Sq ("sum of squares"): somme des carrés. Mean Sq("mean squares"): carré moyen.
F-value: la statistique de Fisher. Pr(>F): la probabilité d'être supérieur à la statistique de
Ficher, soit la P-valeur.

27/71
Dans la deuxième ligne nous avons: Groupe: R met à cet endroit la variable
qualitative qui contient les groupes des individus, c'est-à-dire que la variation est due
aux groupes (inter groupe). Les degrés de liberté inter (ddl) sont le nombre de groupes
moins 1, ici 3 (groupes) – 1 = 2.
Somme des carrés inter: le carré pour chaque groupe se calcule comme suit:
Le nombre des individus dans le groupe*(la moyenne du groupe – la moyenne de
tous les groupes)^2
On fait en suite la somme des carrés obtenus.
Application:
Pour connaître le nombre d'individus dans le groupe G1:
length(Groupe[Groupe = ="G1"]), idem pour G2 et G3.
R donne 7 dans G1, 7 dans G2 et 8 dans G3.
Pour connaître la moyenne du groupe G1:
mean(Poids[Groupe = ="G1"]), idem pour G2 et G3.
R donne 69,3 pour G1, 68,5 pour G2 et 79 pour G3.
La moyenne des trois groupes: mean(Poids), R donne 72,6.
Maintenant nous avons tout ce qu'il faut pour calculer la somme des carrés inter
(SC inter):
Carré 1er groupe = (7*(69,29238-72,57064)^2)= 75,229
Carré 2eme groupe = (7*(68,52768-72,57064)^2)= 114,4185
Carré 3eme groupe = (8*(78,97670-72,57064)^2)= 328,3014
En faisant la somme des trois carrés ci-dessus nous trouvons bien la somme des
carrés inter (517.95) donnée par R dans la table de l'analyse de la variance.
Le carré moyen inter (CM inter) est la SC inter divisée par les ddl inter. Dans notre
exemple ci-dessus: CM inter = 517,95/2 = 258,97.
Dans la troisième ligne nous avons: Residuals: ici la variation est due aux
individus dans les groupes (intra groupe). Le nombre de degrés de liberté = nombre
d'individus – nombre de groupes: 22-3 = 19.

Somme des carrés intra: le carré pour chaque groupe se calcule comme suit:
(La valeur de chaque individu d'un groupe - la moyenne de son groupe)^2
On fait en suite la somme des carrés obtenus.
Le carré moyen intra est la somme des carrés intra divisé par les ddl intra:
La statistique de Fisher (F) est obtenue par CM_inter/CM_intra: 1110,14/19 = 58,43
La P-valeur est la probabilité d'être supérieur à F.
Sous R on peut récupérer cette probabilité ainsi: pf(4.4323,2,19, lower.tail= F) =
0.02631222.

Si nous posons le risque Alpha = 0,05, nous pouvons alors rejeter H0 et affirmer
ainsi la présence d'une différence entre au moins deux moyennes. Nous ne savons pas
cependant quels sont les groupes qui ont des moyennes différentes. Pour le savoir, nous
aurons besoin d'un test qui permet de comparer les moyennes deux à deux. Il y a
plusieurs tests qui sont capables d'effectuer cette comparaison, prenons l'exemple du
test de Tukey:

28/71
TukeyHSD(MonAnova, "Groupe", ordered = FALSE, conf.level = 0.95)

R fournit la réponse suivante:


Fit: aov(formula = Poids ~ Groupe)
$Groupe
diff lwr upr p adj
G2-G1 -0.7646943 -11.1445053 9.615117 0.9808940
G3-G1 9.6843270 -0.3658817 19.734536 0.0601148
G3-G2 10.4490214 0.3988126 20.499230 0.0407639

Ce test donne la différence entre les deux moyennes en questions, les deux bornes
de l'intervalle de confiance ainsi que la P-valeur ajustée. Le résultat de ce test nous
montre finalement (au risque alpha = 0,05), que seules les moyennes des groupes deux
et trois sont différentes entre elles (zéro n'est pas dans l'intervalle), aucune autre
combinaison de moyennes n'est significative.
Récupération de la p-valeur dans la table de l'analyse de la variance: ci-dessous
nous faisons une démonstration sur comment nous récupérons les valeurs dans la table
de l'analyse de la variance et les mettre dans des variables que nous sollicitons selon le
besoin.
Ici nous créons une boîte de dialogue qui nous permet de saisir la valeur de alpha
pour la comparer à la p-valeur dans le but de déterminer si la différence est significative
ou non. Nous fournissons alors la réponse par des boîtes de message.

MonAnova<-anova(lm(Poids~Groupe))
PValue<-MonAnova [5]
PValeur<-as.numeric(unlist(PValue))[1]
PValeur
require (svDialogs)
alpha<-as.numeric(guiDlgInput("Saisir la valeur de alpha"))
f1<- function() {guiDlgMessage("Significatif ", title = "Résultat du Test")}
f2<- function() {guiDlgMessage("Non Significatif ", title = "Résultat du Test")}
if (PValue<alpha) {f1()} else {f2()}

2.1.3.2 Anova à 2 facteurs avec interaction

Nous reprenons la table TaillePoids importée en 2.1.3.1, nous nous intéressons au


poids des individus selon leur sexe et leur groupe:
A<- Anova(lm(Poids ~ Groupe*Sexe, data=TP))
A
Anova Table (Type II tests)
Response: Poids
Sum Sq Df F value Pr(>F)
Groupe 569.80 2 4.6259 0.02598 *
Sexe 59.36 1 0.9638 0.34083
Groupe:Sexe 65.38 2 0.5308 0.59816
Residuals 985.41 16

29/71
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

L'Anova montre un effet du groupe, pas d'effet pour le la variable "Sexe", comme il
n'y a pas d'interaction Groupe*Sexe, c'est-à-dire qu'en changeant de groupe le rapport
"poids homme/poids femme" ne change pas.

2.1.4 Régressi on linéair e

2.1.4.1 Régression linéaire simple

Nous cherchons à savoir ici si "Poids" dépend de "Taille" en ce qui concerne les
individus des trois groupes de notre table TaillePoids vue en 2.1.3.1.
summary(lm(Poids~Taille))

Call:
lm(formula = Poids ~ Taille)

Residuals:
Min 1Q Median 3Q Max
-12.721 -6.944 -1.412 5.427 20.317

Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 43.8295 39.8054 1.101 0.284
Taille 0.1661 0.2298 0.723 0.478

Residual standard error: 8.907 on 20 degrees of freedom


Multiple R-squared: 0.02546, Adjusted R-squared: -0.02327
F-statistic: 0.5225 on 1 and 20 DF, p-value: 0.4781

R teste deux hypothèses:


1) Intercept (H0: Ordonnée à l'origine β0 = 0 ): est-ce que la droite de régression passe
ou non par zéro, dans notre exemple ci-dessus, β0 est estimé (Estimate) à 43,8295, l'écart
type estimé de β0 (Std. Error) est de 39,8054, la statistique t (t value) est de 1,101 (c'est le
rapport: β0/l'écart type estimé de β0). Finalement le test donne une p-valeur (Pr(>|t|) ) de
0,284 pour cette première hypothèse, donc pas de rejet de H0.
2) Taille (H0: la pente β1 = 0): est-ce que la pente en fonction de "Taille"
(cov(Taille,Poids)/var(Taille)) de la droite de régression est différente de zéro. β1 est estimé
(Estimate) à 0,1661, l'écart type estimé de β1 (Std. Error) est de 0,2298, la statistique t (t
value) est de 0,723 (c'est le rapport: β1/l'écart type estimé de β1), cette statistique est la
racine carrée de la statistique de Fisher qui nous permet de calculer la p-valeur. Ici le
rejet est impossible, la p-valeur (Pr(>|t|)) étant de 0,478, carrément au seuil du hasard !!,
donc pas de dépendance entre les deux variables de notre test.
Si la statistique de Fisher dans notre exemple ci-dessus est de 0,522729, avec 1 et 20
ddl ( 1 au numérateur: nombre de variables dans le modèle -1 et 20 au dénominateur:
nombre d'observations – nombre de variables) alors R a procédé comme suit pour
calculer la p-valeur: 1-pf(0.522729, 1,20).

30/71
2.1.4.2 Régression linéaire multiple

Si nous cherchons à tester la dépendance d'une variable quantitative (à expliquer) en


fonction de plusieurs autres (explicatives), il faut mettre le signe "+" entre les variables
explicatives, si nous cherchons à savoir s'il y a une interaction entre les variables
explicatives il faut remplacer le signe "+" par "*":
Exemple:
summary(lm(Note~Taille+Poids))

Call:
lm(formula = Note ~ Taille + Poids)
Residuals:
Min 1Q Median 3Q Max
-5.3790 -2.6135 0.2002 3.5819 4.9872
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 27.30086 16.81318 1.624 0.121
Taille -0.05522 0.09546 -0.579 0.570
Poids -0.09308 0.09171 -1.015 0.323
Residual standard error: 3.653 on 19 degrees of freedom
Multiple R-squared: 0.07734, Adjusted R-squared: -0.01978
F-statistic: 0.7964 on 2 and 19 DF, p-value: 0.4655

Donc ce modèle n'est pas informatif, et aucune des deux variables explicatives
n'apporte d'information significative au modèle.

2.1.5 Tests sta tistiques

2.1.5.1 Test de corrélation

Ce test est uniquement valable pour deux, et seulement deux, variables


quantitatives strictement de même taille. En ce qui concerne la statistique de test ainsi
que la p-valeur, ce test est équivalent à un modèle de régression linéaire simple, tel que
nous l'avons vu en 2.1.4. Bien évidemment les sorties ne sont pas les mêmes selon que
nous nous considérons dans un modèle de régression ou que nous testons simplement la
corrélation entre deux variables. C'est un test bilatéral par défaut utilisant la méthode de
Pearson par défaut aussi, autrement il faut spécifier la méthode: "kendall" ou "spearman".
Ce dernier point est très important parce que les résultats peuvent changer
considérablement selon la méthode choisie. Ci-dessous un même test selon les trois
méthodes:
cor.test(Taille, Poids, method ="p")
Pearson's product-moment correlation
data: Taille and Poids
t = 0.7229, df = 20, p-value = 0.4781
alternative hypothesis: true correlation is not equal to 0
95 percent confidence interval:

31/71
-0.2809422 0.5445412
sample estimates:
cor
0.1595665

cor.test(Taille, Poids, method ="k")


Kendall's rank correlation tau
data: Taille and Poids
T = 123, p-value = 0.6964
alternative hypothesis: true tau is not equal to 0
sample estimates:
tau
0.06493506

cor.test(Taille, Poids, method ="s")


Spearman's rank correlation rho
data: Taille and Poids
S = 1558, p-value = 0.5909
alternative hypothesis: true rho is not equal to 0
sample estimates:
rho
0.1202710

2.1.5.2 Test et intervalle de confiance sur une


proportion

(1) Soit via la binomiale avec un test exact comme suit: nous choisissons le nombre
de succès = 20 et le nombre d'essais=100. L'intervalle de confiance est donné à 0,95 et la
probabilité théorique de succès à 0,5 par défaut. En fait seuls les deux premiers
arguments sont obligatoires:

binom.test(20, 100, p = 0.5, alternative = c("two.sided", "less", "greater"), conf.level =


0.95)
Exact binomial test
data: 20 and 100
number of successes = 20, number of trials = 100, p-value = 1.116e-09
alternative hypothesis: true probability of success is not equal to 0.5
95 percent confidence interval:
0.1266556 0.2918427
sample estimates:
probability of success
0.2
Si l'on ne veut de ce résultat que la p-valeur:
binom.test(20, 100, p = 0.5, alternative = c("two.sided", "less", "greater"), conf.level =
0.95)$p.value
1.115909e-09
Si l'on ne veut de ce résultat que l'intervalle de confiance:
binom.test(20, 100, p = 0.5, alternative = c("two.sided", "less", "greater"), conf.level =
0.95)$conf.int
0.1266556 0.2918427
attr(,"conf.level")
0.95

32/71
Pour récupérer les valeurs des bornes de l'intervalle:
binom.test(20,100)$conf.int[1]# pour la borne inférieure.
0.1266556
binom.test(20,100)$conf.int[2]# pour la borne supérieure.
0.2918427
Cette méthode d'extraction d'un élément des résultats donné par le test est valable
pour les autres tests.
(2) Soit par le test de proportion, lequel effectue la correction de la continuité (par
défaut), sinon il faut le préciser. La probabilité supposée par rapport à laquelle on fait le
test est 0,5 par défaut. L'alternative est bilatérale et l'intervalle de confiance est à 0,95
par défaut. Finalement, seuls les deux premiers arguments sont obligatoires.
Pour plus de détails, voir help("prop.test").
Exemple: testons ici l'égalité entre la proportion observée 20/100 et une proportion
théorique = 0,5.
prop.test(20, 100, p = 0.5, a="t", conf.level = 0.95, correct = TRUE)
1-sample proportions test with continuity correction
data: 20 out of 100, null probability 0.5
X-squared = 34.81, df = 1, p-value = 3.635e-09
alternative hypothesis: true p is not equal to 0.5
95 percent confidence interval:
0.1292482 0.2943230
sample estimates:
p
0.2
Donc rejet de l'hypothèse H0: la vrai proportion = 0,5 au profit de l'alternative.
Pour extraire l'intervalle de confiance de l'ensemble des résultats:
prop.test(20, 100, p = 0.5, alternative = c("two.sided", "less", "greater"), conf.level = 0.95,
correct = TRUE)$conf.int
0.1292482 0.2943230
attr(,"conf.level")
[1] 0.95
Les deux méthodes (binom.test et prop.test) donnent des résultats très différents de
ceux obtenus par l'approximation par la loi normale: p observée ± (quantile de la loi
normale tel que p[X<= x] = 1-alpha/2) *racine( p observée*(1-p observée)/ nb total
d'essais). La différence peut atteindre jusqu'à 3%.
Ci-dessous un programme qui simule cette différence:
ns<-69# nb de succès
nt<-80# nb total d'essais.
alpha<-0.05
p<-ns/nt
binom.test(ns,nt)$conf.int
BornInf<-p-(qnorm(1-alpha/2, mean = 0, sd = 1, lower.tail = TRUE))*sqrt((p*(1-
p))/nt)
BornInf

33/71
BornSup<-p+(qnorm(1-alpha/2, mean = 0, sd = 1, lower.tail = TRUE))*sqrt((p*(1-
p))/nt)
BornSup

2.1.5.3 Test et intervalle de confiance sur l'égalité de


plusieurs proportions

Si nous avons affaire à 2 proportions, nous pouvons alors préciser l'alternative: la


probabilité de succès dans la première proportion est inférieure, égale ou supérieure à
celle de la deuxième. L'intervalle de confiance est fourni dans le résultat. La correction de
la continuité est possible si sa valeur ne dépasse pas la valeur de la différence des deux
proportions (en valeur absolue bien entendu).
Si nous avons affaire à plus de deux proportions, l'alternative est toujours l'égalité, le
test n'établit pas d'intervalle de confiance, et n'utilise jamais la correction de continuité.
La matrice qui contient les proportions ne doit pas comporter plus de deux
colonnes: dans la première on met le nombre de succès et dans la deuxième le nombre
d'échecs, la proportion est alors: (nb succès/(nb succès + nb échecs)).
Exemple: soit la matrice m qui contient 6 proportions:
17 32
57 38
72 64
53 42
39 30
19 27
prop.test(m)
6-sample test for equality of proportions without continuity
correction
data: m
X-squared = 11.5535, df = 5, p-value = 0.04144
alternative hypothesis: two.sided
sample estimates:
prop 1 prop 2 prop 3 prop 4 prop 5 prop 6
0.346 0.600 0.529 0.557 0.565 0.413

2.1.5.4 Test de Student et intervalle de confiance sur


une moyenne

Le test de Student permet de calculer des intervalles de confiances sur une seule
moyenne et sur la différence de deux moyennes.
Nous pouvons préciser la valeur par rapport à laquelle nous voulons tester la
moyenne ou la différence entre deux moyennes (c'est zéro par défaut). Nous pouvons
définir aussi l'hypothèse alternative: différence, inférieur ou supérieur par rapport à une
valeur (c'est la différence qui est testée par défaut). Nous renseignons aussi
l'indépendance, appariés ou non (les deux échantillons du test sont indépendants par
défaut). Nous précisons aussi si les variances sont égales (non égales par défaut) ainsi
que l'intervalle de confiance (0.95 par défaut). Pour plus de détails, voir help("t.test").
Exemple où nous examinons si la moyenne théorique de la variable "Taille" est
supérieure à 169 sachant que celle observée = 173:
t.test(Taille, a= "g", mu = 169) #a = "g" signifie alternative="greater"

34/71
One Sample t-test
data: Taille
t = 2.2419, df = 21, p-value = 0.01795
alternative hypothesis: true mean is greater than 169
95 percent confidence interval:
169.9399 Inf
sample estimates:
mean of x
173.0433
La p-valeur étant < 0,05 nous pouvons prendre la décision de rejeter H0: mu = 169
au profit de l'alternative H1: mu > 169.

Ce test fourni un intervalle de confiance sur la moyenne théorique à partir de la


moyenne observée dans l'échantillon.
t.test(Taille)$conf.int
169.2927 176.7938
attr(,"conf.level")
0.95
Vérifions manuellement comment R établit cet intervalle: l'IC sur la moyenne d'un
échantillon est calculé comme suit (alpha est la probabilité de se trouver en dehors de
l'intervalle):
mu0: moyenne de l'échantillon (variable aléatoire, inconnue), mu: moyenne
observée dans l'échantillon. t: la statistique de Student à 1-alpha/2 et à n-1 ddl. sd:
l'écart-type de l'échantillon et n est sa taille
IC(mu0) = [ mu ± t * (sd/racine(n))]
Avec R nous obtenons les valeurs suivantes:
mu<-mean(Taille)# moyenne de l'échantillon.
sd<-sd(Taille)# écart-type de l'échantillon.
n<-length(Taille)# taille de l'échantillon.
t<-qt(0.975,21)# statistique de Student.
BSup<-mu+t*sd/sqrt(n)# borne supérieur.
BInf<-mu-t*sd/sqrt(n)# borne inférieur.
BSup
176.7938
BInf
169.2927
Donc notre procédé ci-dessus est exactement la même utilisé par R pour
l'établissement d'un IC sur la moyenne d'un échantillon.

2.1.5.5 Test de Student et intervalle de confiance sur


l'égalité de deux moyennes

Soit la table TaillePoids vue en 2.1.3.1. Si nous voulons tester la différence entre
deux moyennes issues de deux échantillons INDEPENDNATS:
t.test(Taille~(Groupe=="G1"|Groupe=="G2"), a= "t", mu = 0, paired = FALSE,
var.equal = TRUE,conf.level = 0.95)

35/71
R teste si la différence entre les deux échantillons, où la soustraction se fait terme à
terme, est égale ou non à zéro:
Two Sample t-test
data: Taille by Groupe == "G1" | Groupe == "G2"
t = 1.3433, df = 20, p-value = 0.1942
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
-2.732581 12.617087
sample estimates:
mean in group FALSE mean in group TRUE
176.1883 171.2461

Si nous voulons tester la différence entre deux moyennes issues de deux


échantillons APPARIES (le même échantillon avant et après un traitement):
Il faut faire attention au fait que R n'accepte pas de sélectionner deux ensembles
parmi d'autres dans une variable comme nous avons fait avec le test des échantillons
indépendants, où nous avons spécifié "G1" et "G2" de la variable "Groupe" qui contenait
"G1", "G2" et "G3", (Taille~(Groupe=="G1"|Groupe=="G2"). Il exige ici que la variable
"Groupe" contienne exactement deux ensembles. Nous allons ainsi créer une variable
"GroupeTP2" qui ne contient que "G1" et "G2" et une variable "TailleTP2" qui ne contient
que les tailles des individus de l'ensemble "G1" et celles de l'ensemble "G2":
GroupeTP2<-Groupe[Groupe == "G1"|Groupe == "G2"]
TailleTP2<-Taille[Groupe == "G1"|Groupe == "G2"]
t.test(TailleTP2~GroupeTP2, a= "t", mu = 0, paired = T, var.equal = TRUE,conf.level
= 0.95)

Paired t-test
data: TailleTP2 by GroupeTP2
t = 2.1214, df = 6, p-value = 0.07813
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
-0.6819203 9.5700301
sample estimates:
mean of the differences
4.444055
Nous remarquons que le résultat du test, pour les mêmes échantillons, n'est pas du
tout le même selon que les échantillons sont appariés ou non.
Pour établir un IC sur la différence de deux moyennes des groupes "G1" et "G2", on
peut faire:
t.test(Taille~(Groupe=="G1"|Groupe=="G2"))
R suppose avec ce test que les variances ne sont pas connues, mais estimées à
partir des échantillons comme il suppose que les échantillons sont indépendants. Ce test
fourni tout un ensemble de résultats, nous nous intéressons ici uniquement à l'IC, on
peut restreindre le résultat au seul élément qui nous intéresse avec l'opérateur "$":
t.test(Taille~(Groupe=="G1"|Groupe=="G2"))$conf.int
-4.066453 13.950959
attr(,"conf.level")
0.95

36/71
La différence de deux moyennes suit une loi de Student dont la statistique (t
observé) peut être calculée comme ci-dessous sous R:
tobs<-(mean(G1)-mean(G2))/sqrt(sr*(1/length(G1)+1/length(G2)))
où sr est calculé comme suit:
sr<-(var(G1)*(length(G1)-1)+var(G2)*(length(G2)-1))/(length(G1)+length(G2)-2)
pour calculer la p-valeur (fournie d'ailleurs par le test):
(1-pt(tobs,12))*2# "pt" renvoie la probabilité d'être entre moins l'infini et le quantile
"tobs", comme notre test est bilatéral, nous multiplions le résultat par deux. Nous
obtenons la même valeur donnée par R lors du test.

2.1.5.6 Test de Fisher exact

Ce test évalue l'égalité entre deux et seulement deux proportions (comme un Chi-
deux), réputé puissant pour les échantillons de petits effectifs, contrairement au Chi-
deux utilisé dans prop.test() qui pourrait générer des résultats pas très exacts en cas
d'effectif inférieur à 5. Pour un nombre de proportions supérieur à 2, il faut faire un khi-
deux comme nous l'avons vu en 2.1.5.2, on n'a pas le choix. Pour un même jeu de
données, ces deux tests - fisher.test() et prop.test() - fournissent tout de même des
résultats légèrement différents.
Exemple: nous allons juste comparer la p-valeur et IC donnés par le test exact de
Fisher et par le test de Khi-deux respectivement:
fish<-matrix(c(17,68,24,80),byrow= T, ncol=2)
fisher.test(fish)$p.value
0.7232012
prop.test(fish)$p.value
0.7389976
fisher.test(fish)$conf.int
0.3859217 1.7721783
attr(,"conf.level")
0.95
prop.test(fish)$conf.int
-0.15888101 0.09734255
attr(,"conf.level")
0.95

2.1.5.7 Test du Chi-deux

Le test du Chi-deux chisq.test() est identique au test sur l'égalité de plusieurs


proportions prop.test(), lorsque la matrice ne contient que deux colonnes, succès vs.
échec respectivement, comme vu en 2.1.5.2.
Exemple: soit la matrice m définie comme ci-dessous:
17 32
57 38
72 64
53 42
39 30
37/71
19 27
prop.test(m,correct = TRUE)

6-sample test for equality of proportions without continuity correction


data: m
X-squared = 11.5535, df = 5, p-value = 0.04144
alternative hypothesis: two.sided
sample estimates:
prop 1 prop 2 prop 3 prop 4 prop 5 prop 6
0.3469388 0.6000000 0.5294118 0.5578947 0.5652174 0.4130435

chisq.test(m, correct = TRUE)


Pearson's Chi-squared test
data: m
X-squared = 11.5535, df = 5, p-value = 0.04144

Lorsque la matrice contient plus de 2 colonnes, le test sur les proportions n'est plus
possible, seul celui du Chi-deux est possible.
Exemple: soit la matrice mm définie comme suit:
mm<-insertCol(m, 3, c(28,26,33,42,51,46))
prop.test(mm,correct = TRUE)
Erreur dans prop.test(mm, correct = TRUE) : 'x' doit avoir 2 colonnes

chisq.test(mm,correct = TRUE)
Pearson's Chi-squared test
data: mm
X-squared = 49.7732, df = 10, p-value = 2.938e-07

2.1.5.8 Test de normalité (Shapiro-Wilk)

Pour tester la normalité d'une distribution: les données manquantes sont autorisées
dans la variable dont on veut tester la distribution, mais elle doit contenir entre 3 et
5000 valeurs:
Exemple: soit la table TaillePoids importée en 2.1.3.1, nous voudrions savoir si les
tailles des individus suivent une loi normale, donc le test porte sur la variable Taille:
attach(TP)
shapiro.test(Taille)
Shapiro-Wilk normality test
data: Taille
W = 0.9669, p-value = 0.6387
Le test sort 4 informations: le nom du test, la variable analysée, la statistique du test,
W, ainsi que la p-valeur. Pour récupérer cette dernière dans une variable que l'on pourra
manipuler par la suite:
PValeur<-as.numeric(shapiro.test(Taille)[2])
Donc, résultat du test, nous pouvons admettre que la taille suit une distribution
gaussienne.

38/71
2.1.5.9 Test de Fisher pour la comparaison de deux
variances

tapply(TP$Poids, TP$Sexe, var, na.rm=TRUE)


F G
106.58252 55.47561

var.test(Poids ~ Sexe, alternative='two.sided', conf.level=.95, data=TP)

F test to compare two variances


data: Poids by Sexe
F = 1.9213, num df = 10, denom df = 10, p-value = 0.3180
alternative hypothesis: true ratio of variances is not equal to 1
95 percent confidence interval:
0.5169109 7.1408867
sample estimates:
ratio of variances
1.92125

Le résultat du test indique que la variance des poids n'est pas différente suivant la
variable "Sexe".

2.1.5.10 Test de Bartlett sur l'homogénéité des


variances

bartlett.test(Note ~ Groupe, data=TP)


Bartlett test of homogeneity of variances

data: Note by Groupe


Bartlett's K-squared = 1.6608, df = 2, p-value = 0.4359
Pas de rejet de H0, les variances sont homogènes.

2.1.6 Opéra tions sur l es listes


baba=list(pipou=c(5:25),poids=100,type="crac")
Pour visualiser les composantes d'une liste
names(baba)
[1] "pipou" "poids" "type"
summary(baba)
Length Class Mode
serie 100 -none- numeric
taille 1 -none- numeric
type 1 -none- character
Pour atteindre les composantes d'une liste
baba$poids OU >baba[[2]]

39/71
[1] 100 [1] 100

2.1.7 Lois de pr obabilité sous R (18 lois)


Ce paragraphe traite des lois de probabilité qui permettent de générer des valeurs
suivant la loi en question et selon les paramètres spécifiés entre parenthèses. La
première lettre "r" sera remplacée par "p" si nous cherchons la probabilité au-delà ou en
deçà d'un quantile (que nous devons fournir bien sûr). La première lettre "r" sera
remplacée par "d" si nous cherchons un quantile connaissant la probabilité d'être au-
delà ou en deçà (une probabilité que nous devons fournir bien sûr).

rbeta(n, shape1, shape2) #Beta


rbinom(n, size, prob) #Binomial
rcauchy(n, location=0, scale=1) #Cauchy
rchisq(n, df) #Chi2 (Pearson)
rexp(n, rate=1) #Exponentielle
rf(n, df1, df2) #Fisher-Snedecor
rgamma(n, shape, scale=1) #Gamma
rgeom(n, prob) #Géométrique
rhyper(nn, m, n, k) #Hypergéométrique
rlnorm(n, meanlog=0, sdlog=1) #Lognormale
rlogis(n, location=0, scale=1) #Logistique
rnbinom(n, size, prob) #Binomiale négative
rnorm(n, mean=0, sd=1) #Normal
rpois(n, lambda) #Poisson
rsignrank(nn, n) #Wilcoxon (rangs signés)
rt(n, df) #Student
runif(n, min=0, max=1) #Uniforme
rweibull(n, shape, scale=1) #Weibull
rwilcox(nn, m, n) #Wilcoxon (sommes des rans)

Par exemple, pour voir le "Usage" de la loi normale, il faut faire help("rnorm").

dnorm(x, mean = 0, sd = 1, log = FALSE)


pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
qnorm(p, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)
rnorm(n, mean = 0, sd = 1)

40/71
2.2 Algorithmique

2.2.1 Exempl e de boucl es


XX<-seq(4,22,2)# crée une séquence allant de 4 à 22 par pas de 2.
XX # pour voir ce que XX contient
for (i in 1: length(XX)){
if (XX[i] < 10) {cat(XX[i],'valeur inférieure à 10', '\n')
}
}
#si i<10 je demande qu'il m'affiche cette valeur, qu'il affiche la phrase:
#valeur inférieure à 10 et qu'il fasse un retour à la ligne après chaque exécution,
# c'est grâce à '\n'. que je ne précise pas le lieu d'affichage ici, le lieu
# par défaut est R Console.
else
if (XX[i] ==10) {cat(XX[i],'cette valeur est égale à 10 !!!','\n')
}
else {
cat(XX[i], file = "D:\\Mes documents\\ARKESYS_STAGE_STATS\\vir2.R",
fill = TRUE, 'valeur supérieure à 10', append = TRUE)
}
}#ici je demande qu'il m'affiche la valeur de i, je précise que cette partie du
#résultat doit être envoyée à l'adresse
#D:\\Mes documents\\ARKESYS_STAGE_STATS\\vir2.R
#"fill" joue le même rôle que '\n', c'est à dire un retour à la ligne après chaque
#exécution. "append" sert à demander d'effacer les exécutions au fur et à mesure
#et ne garder que le résultat de la dernière exécution FALSE, ou de les garder
#toutes TRUE.
Exemple ave "Tant que":
XX<-seq(4,22,2)# crée une séquence allant de 4 à 22 par pas de 2.
XX
for (i in 1: length(XX)){
while (XX[i]<15){cat (XX[i], '\n'); break
}
}

Exemple de fonction simple et saisie d'arguments par interface graphique


La fonction fonc a 3 arguments, elle obtient leur somme et leur produit:
fonc<-function(x, y, z) {
s<-sum(x,y,z)

41/71
p<-(x*y*z)
return(paste("le produit =", p ,"la somme =", s ))
}
Exemple: fonc(2,3,12)
Si nous voulons rentrer les valeurs des arguments via une interface graphique (installer
et charger au préalable le package "fgui":
install.packages("fgui", dep =T)# Installer.
require(fgui)# Charger.
gui(fonc)

Somme/différence de deux matrices en matrice:


Soit les deux matrices M et N définies comme ci-dessous:
M<-as.matrix(cbind(c(1:4),seq(1,8, by =2),rep(3,4)))
N<-matrix(c(1,4,6,7,9,1,4,3,7,8,3,4),nrow=4)
MAT <-M

for (i in 1:nrow(M)){
for (j in 1:ncol(M)){
if (M[i,j]<4 & N[i,j]<5){
MAT[i,j]<-M[i,j]+N[i,j]}
else
if (M[i,j]>8|N[i,j]>7){
MAT[i,j]<-M[i,j]-N[i,j] }
else MAT[i,j]<-500
}
}
MAT

2.2.2 Exempl e de boîte de dialogue


La fonction "comparer" ci-dessous permet la comparaison de deux valeurs, dont
une est saisie à l'écran par une boîte de dialogue et une autre connue par la fonction:
require(svDialogs)
m<-10
comparer<- function () {
seuil<-as.numeric(guiDlgInput(message = "saisir la valeur du seuil",
title = "Seuil Alpha"))

if (m < seuil) {
cat('le seuil valant', seuil, 'est supérieur la moyenne' , m)
}

42/71
else {
cat('le seuil estimé à', seuil, 'est inférieur la moyenne' , m)
}
}
comparer()

Cette fonction "seuil" ci-dessous permet la saisie de données à l'écran avec contrôle.
seuil<-function() {
require (svDialogs)#charger le package où la fonction "guiDlgInput" existe.
N<-0 #compteur
repeat{
A<-as.numeric(guiDlgInput("Saisir la valeur de A")) #fenêtre de saisie
B<-as.numeric(guiDlgInput("Saisir la valeur de B"))
if (A < 5&B!=0) #si A inférieur à 5 et B différent de 0
{N<-N+1; Z<-A/B; cat('à la saisie numéro', N, ', A était inferieur à 5,
A=',A,'\n',
#incrémenter le compteur de 1, diviser A par B et afficher
#dans R console ce qui est entre parenthèses.
'B était différent de zéro, B=',B,'\n', 'Z=A/B=',Z,'\n')
}
else
if (A==5) {cat('A est égale à 5, A=', A, '\n')
}
else
if (A>5) {cat('lors de la dernière saisie, A était supérieur à 5,
A=', A, ', On arrête la saisie','\n'); break
}
else
if (B == 0){cat('lors de la dernière saisie, B était égal à 0,
B=', B,'division interdite. On arrête la saisie','\n'); break
}
next
}
}
seuil()

Exemple sur l'utilité des boîtes de dialogue:


FIC <- function() {
read.xls("D:\\Stage_Stats\\BattementCoeur.xls")
attach (FIC)
Z<-t.test(RythmeCardiaque~Traitement)

43/71
summary(Z)
attach(Z)
PV<-p.value
if (PV>0.05){print("NON SIG")} else {print("SIG")}

44/71
2.3 Interfaces statistiques libres
On distingue traditionnellement deux voies pour le dialogue avec R:
(1) la CLI (Command Line Interface), c'est la fenêtre de R-Console, parce que la R-
Console est aussi la barre de menu et les fonctionnalités qui lui sont liées. C'est
l'interface par défaut livrée avec R, elle permet une manipulation totale des données.
Cette flexibilité la rend une interface très populaire auprès d'un public maîtrisant les
détails mathématiques et algorithmiques et ayant en même temps des besoins
spécifiques. Cette interface est aussi adoptée par un public qui a incessamment
l'obligation d'adapter ses calculs. Elle offre par ailleurs pour un utilisateur non
professionnel la possibilité d'effectuer des statistiques élémentaires sur les données,
comparable à ce qu'offre une calculatrice scientifique très commode et très puissante.
Cette interface s'avère vite fastidieuse lorsque nous sommes amenés à effectuer un
grand nombre d'opérations qui se répètent à quelques détails près. Nous avons vu plus
haut que pour importer une table par exemple, il faut écrire toute une ligne
d'instructions où la moindre erreur peut empêcher l'importation voire se répercuter sur
les données importées et les altérer.
(2) les GUI (Graphical User Interface), au pluriel. En effet, les GUI sont plusieurs,
certaines sont gratuites et d'autres sont payantes, nous nous intéresserons par la suite
uniquement à celles qui sont gratuites. Ces interfaces ont été développées par des
personnes (laboratoires) différentes, certaines ont été menées à termes, et d'autres ont
été abandonnées en cours de route, comme Obversive, StatPaper et RWeb. Le grand
avantage des GUI est que nous n'avons pas à saisir la ligne de commande nous-mêmes
pour les opérations proposées. Comme nous pouvons les modifier et les faire exécuter
par R si les résultats de l'opération ne sont pas tout à fait conformes à nos attentes. Les
GUI maintiennent en général la CLI présente pour compléter un éventuel détail qui n'a
pas été prévu par la GUI en question.

La GUI s'avère indispensable dans le cas d'un usage professionnel où une opération
peut être sollicitée un nombre de fois très important. L'accès aux instructions et la
possibilité de les modifier ne sont pas les mêmes selon l'interface. La modification n'est
pas possible parfois, les opérations qui sont alors possibles se limitent à celles
proposées. Ceci rend la GUI très contraignante et très limitée même si le nombre
d'opérations qu'elle offre est très important. Nous en détaillerons ci-dessous quelques-
unes que nous avons installées et testées nous-mêmes.

2.3.1 SciViews:
C'est une interface très pédagogique, simple et conviviale dédiée aux opérations
statistiques de base, à titre d'exemple: statistiques descriptives, régression, Anova. Elle
dispose également d'un ensemble de tests paramétriques et non paramétriques. Elle est
équipée d'un dispositif permettant la représentation graphique des données. Elle peut
substituer aux tables statistiques pour les lois normale, de Student, de Poisson,
Binomiale, Chi-deux et Fisher (on récupère la probabilité à partir d'un quantile et
inversement). Elle n'est malheureusement plus mise à jour, et semble être définitivement
abandonnée par ses auteurs. Ainsi, elle n'est pas compatible avec les dernières versions
de R, comme elle ne marche pas sous Vesta (elle marche sous Windows 2000 et Windows
XP). La dernière version de R compatible avec cette interface est R-2.2.1. Donc il faut
installer SciViews et R-2.2.1. via ces deux liens SciViews-R_0.9-2Setup.exe (9,5 Mo) et R-
2.2.1-SciViews_0.9-2.exe (69,4 Mo), et mettre les deux dans le même répertoire choisi par

45/71
défaut lors de l'installation. Si l'on clique 2 fois sur l'icône de SciViws la version 2.2.1. de
R démarra alors automatiquement pour la supporter.

Cette interface a trois fenêtres, figure 3. (1) fenêtre de message où l'on lit la réponse
à l'exécution, en fait cette fenêtre ni plus ni moins que la CLI (Command Line Interface),
c'est-à-dire que nous pouvons écrire des commandes et les exécuter, (2) fenêtre
d'opérations: elle répertorie toutes les opérations possibles par cette interface ainsi que
des opérations sur les tables: importer, exporter, renommer, supprimer et ajouter des
lignes et des colonnes dans une table, etc. (3) fenêtre de commandes: elle garde
uniquement les commandes passées. Nous pouvons dans cette fenêtre sélectionner des
lignes de commandes et les exécuter grâce à un bouton qui se trouve au niveau de cette
fenêtre.
Son grand avantage est qu'elle se greffe sur R sans gêner en rien ceux qui sont
habitués à l'usage de la CLI, parce qu'on peut continuer à travailler comme si rien n'était
et la faire intervenir quand on a besoin d'elle.
Un document pdf de 28 pages rédigé par Faouzi LYAZRHI expliquant comment se
servir de cette interface existe sur le lien :
http://www.biostat.envt.fr/spip/IMG/pdf/Une_introduction-a-SciViews-
2.pdf
Nous nous sommes beaucoup servi de ce dernier document que nous avons trouvé
très utile pour installer SciViews et l'utiliser.

Figure 3. Fenêtre de l'interface SciViews. 46/71


2.3.2 R-Commander
Contrairement à SciViews, cette interface n'est pas un logiciel qui démarre en même
temps que R, mais c'est un package qu'il faut installer (avec d'autres packages dont il
dépend, ils sont nombreux !) et solliciter avec la commande library(), donc pour démarrer
l'interface: library(Rcmdr). Pour certaines versions de R, il faut écrire le nom du package
entre guillemets: library("Rcmdr"). R-Commander a besoin de R pour démarrer, mais une
fois démarré, contrairement à SciViews, il n'a pas besoin de la CLI, il est autonome.
Cette interface dispose de 3 fenêtres, figure 3. (1) fenêtre de script: cette partie
conserve uniquement la syntaxe des commandes passées depuis la barre de menu, nous
pouvons réexécuter une ou plusieurs lignes de commande en faisant Soumettre. (2)
fenêtre de sortie: dans cet espace nous avons la syntaxe de chaque commande passée
depuis la barre de menu suivie du résultat de l'exécution. (3) fenêtre de messages: ici
nous avons des notes et des messages d'erreur.
Importation, Exportation et manipulation des données:
R-Commander permet l'importation sous R des données de provenance et de
formats divers, format texte (.txt), depuis un lien URL (internet), des données SPSS,
MiniTab, STATA, Excel, Access ou dBase. Comme elle permet l'exportation des données
sous format texte.
R-Commander permet aussi la création de tables où la saisie se fait directement
dans l'nterface sous format tableur (comme Excel). Nous pouvons aussi recoder les
variables, en créer des nouvelles, les renommer, les supprimer, etc. L'avantage de cette
interface par rapport à un logiciel classique de statistiques, est que nous avons accès
aux lignes de commande (CLI: Command Line Interface). Ce dernier point permet une
manipulation plus fine et plus rapide des données ainsi que des représentations
graphiques instantanées, c'est parce que le traitement des variables s'effectue
virtuellement (contrairement à Excel, pas besoin d'aller sélectionner les valeurs d'une
variable ou d'un individu pour effectuer des opérations le concernant.
En plus de la barre de menu, R-commander comporte trois boutons, figure 4: (1)
Editer: permet de voir les données d'une table, les modifications sont conservées. (2)
Visualiser: permet de voir les données d'une table, les modifications ne sont pas
possibles. Pour visualiser des données qu'on peut modifier sans conserver les
modifications, il faut faire edit(NomTable) dans la CLI. Soumettre: Permet l'exécution des
lignes des commandes sélectionnées dans la fenêtre des scriptes.
Barre de menu: Cette interface dénombre 37 opérations de calculs statistiques
possibles. Voir Annexe I pour la liste exclusive (intitulé en français) de toutes les
opérations offertes par cette interface.
Avantages et inconvénients: Le message d'erreur ne désigne pas avec précision
l'endroit où l'erreur s'est produite, dans la CLI l'endroit de l'erreur est explicitement
montré.
La CLI peut parcourir toutes les commandes qui ont été exécutées avec les flèches,
vers le haut ou vers le bas, chose qui n'est pas possible avec R-Commander où il faut
aller chercher la commande concernée dans la fenêtre des scripts, la sélectionner et faire
Soumettre. Ce détail s'avérera fastidieux si nous avons une longue session et une fenêtre
de scripts qui fait plusieurs pages !!
Dans la CLI on ne peut écrire qu'à la fin de la page, alors que dans la fenêtre des
scripts de la R-Commander on peut écrire n'importe où, c'est plutôt un inconvénient
parce qu'il faut vérifier que nous sommes bien positionnés avant d'écrire, alors que cette
question ne se pose pas pour la CLI.

47/71
L'avantage de la R-Commander est que l'on peut exécuter une commande sans
compléter forcément la précédente. C'est intéressant pour les lignes de commandes
longues que nous devons compléter au fur et à mesure qu'on obtient des résultats.
Lorsqu'il n'y a que la R console qui est ouverte avec la R-Commander, la fenêtre de
l'interface R-Commander a l'inconvénient de disparaître quand on cherche à la déplacer,
donc elle se déplace en arrière plan et réapparaît lorsqu'on relâche la souri,
redimensionner la fenêtre est par conséquent impossible dans ce cas-là. Donc pour
manipuler cette fenêtre normalement il faudra ouvrir une autre application (Word, par
ex.) qui fait tampon entre la R console et la R-Commander, il faut que la fenêtre de cette
tierce application s'interpose entre les deux fenêtres !!
Cette interface a fait l'objet d'une publication dans Journal of Statistical Software par
son auteur principal John Fox de l'université McMaster, la référence est ci-dessous.
The R-Commander: A Basic-Statistics Graphical
User Interface to R
September 2005, Volume 14, Issue 9.
http://www.jstatsoft.org/

Fenêtre
de
script

Fenêtre
de
sortie

Fenêtre
de
messages

Figure 4. Fenêtre de l'interface R-Commander.


48/71
2.3.3 Tinn-R
C'est l'interface la plus exhaustive et la plus perfectionnée que nous ayons trouvée
pendant notre recherche portant sur les interfaces graphiques relatives aux opérations
statistiques. Paradoxalement cette interface ne nous intéresse pas, parce qu'elle est
d'une telle complexité qu'il faudrait une formation à part entière pour apprendre à s'en
servir. Nous rappelons à ce niveau que le public de stagiaires formé à Arkesys effectue
des stages très courts, de deux à trois jours majoritairement, et ne peut pas se permettre
de passer beaucoup de temps pour apprendre à maîtriser l'outil, d'autant plus qu'il ne
s'agit pas d'un public expert en matière de statistiques.
Tinn-R démarre R à la première exécution, l'échange est direct entre les commandes
écrites en Tinn-R et le résultat de l'exécution qui s'affiche dans la CLI. L'interaction entre
l'interface Tinn-R et la CLI de R (où nous voyons les instructions exécutées) semble
comporter cependant une certaine incohérence, puisque la CLI renvoyait l'objet
"NomVariable" non trouvé lorsque nous exécutions un script depuis la Tinn-R.

Figure 5. Fenêtre de l'interface Tinn-R.

Figure 5. Fenêtre de l'interface Tinn-R.

49/71
2.3.4 JGR (Java GU I for R)
Cette interface n'est pas orientée vers les opérations statistiques, elle ne contient
pas des fonctions qui permettent l'automatisation de certaines opération, pas plus que la
CLI. C'est pour cette raison que nous contentons d'en dresser une description brève,
sans aller au-delà, parce que nous considérons qu'elle n'est pas adaptée aux besoins des
stagiaires d'Arkesys.
JGR dispose cependant de fonctionnalités très pratiques et remédie aux problèmes
d'ergonomie que connaît R. En effet JGR, dit "Jaguar" dans le langage des usagers de R,
permet une mise en forme de la syntaxe des scripts, visible sur la figure 6. Par exemple
les commentaires sont en italique et en vert, en bleu clair le texte à imprimer, en bleu
foncé les opérateurs, etc. Cette facilité n'est pas l'exclusivité de JGR, elle est disponible
sur Tinn-R aussi, sauf que JGR est plus simple et plus intuitive que Tinn-R.
Quelque soit le niveau de l'utilisateur de R, expert ou novice, il est pratiquement
impossible de retenir les arguments de toutes les fonctions dont on a besoin, de leur
ordre, entre guillemets ou pas..., un autre apport fondamental de cette interface est
cependant le rappel des arguments des fonctions R au court de leur écriture. En effet, et
dès que le nom de la fonction est CORRECTEMENT écrit et que la première parenthèse
est ouverte, une fenêtre montrant la totalité des arguments possibles, de leur ordre et de
leur syntaxe s'affiche dans la fenêtre des commandes et accompagne l'utilisateur jusqu'à

Figure 6. Fenêtre de l'interface JGR.

50/71
la fermeture de la parenthèse (voir figure 6, en bas à gauche). Elle est la seul interface
(gratuite) que nous connaissions qui offre cette facilité.
Nous ne détaillerons pas davantage cette interface, parce que ce n'est pas le topos
ici, notre recherche, rappelons-le, porte sur des interfaces ayant développé des
fonctionnalités relatives aux opérations statistiques.

51/71
3 Adaptation

3.1 Adaptation de R Console


Au démarrage de R plusieurs répertoires sont parcourus par le logiciel à la
recherche de fonctions à exécuter. Le fichier où l'on doit écrire les fonctions qu'on
souhaite exécuter au démarrage de R s'appelle "Rprofile.site". Si l'on n'a pas choisi un
autre répertoire que celui proposé par R lors de son installation, ce fichier se trouve par
défaut alors à l'emplacement suivant:
"C:\\Program Files\\R\\R-2.8.1\\etc\\Rprofile.site".
On peut l'ouvrir avec un éditeur de textes simples (WordPad, Bloc-notes, etc) et
introduire des fonctions en langage R interprétables par le logiciel. Ces fonctions seront
lues au démarrage, si l'on demande leur exécution automatique, le résultat de leur
exécution se manifestera tout de suite après le démarrage (ou un message d'erreur en
cas de problème).
On peut se satisfaire au stade de démarrage de la simple lecture des fonctions et
remettre leurs exécutions à plus tard. L'exécution peut être effectuée par des appels
depuis des fenêtres graphiques. Des fenêtres que nous créons pour des objectifs précis et
que nous relions à ces fonctions. Donc nous pouvons reprofiler R.
Cette possibilité "de reprofiler R" intéresse particulièrement la société Arkesys qui
peut alors adapter le logiciel aux besoins de ses clients, parce qu'une fenêtre peut être
une série d'exercices relatifs à un thème (régression, anova, etc). Arkesys peut créer ainsi
plusieurs fenêtres adaptées, parallèles à R, qu'elle distribuera à ses stagiaires biologistes,
économistes, industriels, etc, et ceci sans avoir besoin de rendre compte à quelque
organisation que ce soit.
Les adaptations que nous avons effectuées sur la R Console:
La barre de menu affiche par défaut uniquement les boutons qu'on voit sur la figure
ci-dessous, figure 7:

Figure 7. Barre de menu par défaut.

Le fait de solliciter des fonctions R depuis la barre de menu de la R Console est bien
plus commode pour l'usager (qu'il soit naïf ou expert) que les solliciter depuis une fenêtre
indépendante, qui est tantôt en premier plan tantôt en arrière plan. Si l'interface a
cependant besoin d'une structure large (beaucoup de fonctions s'encapsulent) le recours
à une fenêtre indépendante peut s'avérer obligatoire.
Ci-dessous 3 exemples de programmes qui créent des boutons dans la fenêtre de R
Console où chaque bouton affiche en cascade 3 fonctions. Nous donnons la syntaxe et le
résultat du programme entre des signes "=". Nous rappelons que ces programmes sont à
introduire dans le fichier "Rprofile.site" pour être lus au démarrage de R.

52/71
Nous notons bien ici que le but est la démonstration en soi, nous n'avons peut-être
pas choisi les fonctions les plus judicieuses à représenter, en général les plus
compliquées.
Exemple 1: Création du bouton "Aide packages" et les fonctions que l'on peut appeler depuis,
figure 8:

Figure 8, montre les fonctions liées au bouton "Aide packages".

================================================
#Début de l'exemple 1.
contenu_pkg <- function () {
contenu<-winDialogString("Saisir le nom du package après les deux points",
"package:")
#"winDialogString" est une fonctions qui ouvre une boîte de dialogue, elle
#récupère le texte saisi et elle le met dans une variable.
ls(contenu)
}
liste_pkg<- function () {installed.packages()
}
fonction_pkg <- function () {
fonction<-winDialogString("Saisir le nom la fonction ", "")
find(fonction)
}
winMenuAdd("Aide packages")
winMenuAddItem("Aide packages", "Visualiser le contenu d'un package déjà
installé", "contenu_pkg()")
winMenuAddItem("Aide packages", "Voir les packages déjà installés", "liste_pkg()")
winMenuAddItem("Aide packages", "Chercher à quel package appartient une
fonction","fonction_pkg()")
#Fin de l'exemple 1.
================================================

53/71
Exemple 2: Création du bouton "Rechercher" et les fonctions que l'on peut appeler depuis, figure
9:

Figure 9, montre les fonctions liées au bouton "Rechercher".

================================================
#Début de l'exemple 2.
winSearch <- function() {
string <- winDialogString("Search string", "")
RSiteSearch(string)
}
#Recherche d'un mot
Rech <- function() {
Chaine <- winDialogString(" Rentrer la fonction R", "")
help(Chaine)
}
A_propos_de<-function() {
Chaine<-winDialogString("Rechercher une fonction dont le nom contient:", "")
apropos(Chaine)
}
winMenuAdd("Rechercher")
winMenuAddItem("Rechercher", "Recherche sur R Site Search", "winSearch()")
winMenuAddItem("Rechercher", "Recherche une fonction R", "A_propos_de()")
winMenuAddItem("Rechercher", "Aide sur une fonction R", "Rech()")
#Fin de l'exemple 2.
================================================

54/71
Exemple 3: Création du bouton "Interface statistique" et les fonctions que l'on peut appeler
depuis, figure 10:

Figure 10. montre les fonctions liées au bouton "Interface statistique".

================================================
#Début de l'exemple 3: Ajout interface statistique dans la barre de menu R.
f3 <- function(...){
library(Rcmdr)
disp()
}
winMenuAdd("Interface Statistique")
#Crée le bouton Interface Statistique dans la barre de menu.
disp<-function () {winMenuDel("Interface Statistique")
}
#permet d'effacer le bouton de la barre de menu
winMenuAddItem("Interface Statistique", "Démarrer R-Commander", "f3()")
#Ajoute le bouton Démarrer R-Commander au bouton Interface statistique
winMenuAddItem("Interface Statistique", "En savoir plus sur R-Commander ", "f4()")
winMenuAddItem("Interface Statistique", "Faire disparaître ce bouton ", "disp()")
#winMenuDel(menuname)
#Fin de l'exemple 3.
================================================

55/71
3.2 Création de fenêtres au démarrage de
R

Durant le stage, nous sommes parvenus à créer plusieurs fonctions que nous avons
introduites dans le fichier "Rprofile.site" pour demander à R de les lire. Certaines sont à
exécution automatique, telle l'affichage de certaines fenêtres sur le bureau, et d'autres à
exécution différée qui seront appelées via des boutons supportés par les fenêtres en
question.

Exemple 1: Création d'une fenêtre simple comportant uniquement deux boutons, le


premier permet de démarrer l'interface statistique R-Commander et le second permet
d'afficher un texte donnant des informations à propos de cette interface. Dans la fenêtre
du texte nous avons inséré dans la barre de menu un bouton "Rechercher" qui permet de
rechercher des informations sur Internet à propos d'un mot qu'on saisit dans une boîte
de dialogue, c'est juste pour montrer comment faire pour encapsuler les fonctions R et
les appeler à des niveaux différents.
Si l'on copie et colle l'exemple 1 (compris entre 2 lignes de "=") dans la CLI (ou dans un
script qu'on exécute), on doit avoir la fenêtre ci-dessous comme résultat.

Nous rappelons que l'interface R-Commander démarre une seule fois par session R,
c'est-à-dire que si l'on la ferme et que l'on veut la redémarrer à nouveau, il faudra fermer
et redémarrer R.
===================================================================
#Début de l'exemple 1.
tt <- tktoplevel(background = "Gray")
#création de la fenêtre 1 dans laquelle les boutons apparaîtront.
tkwm.title(tt,"Démarrage de la R-Commander")
# titre de la fenêtre 1
f3 <- function(...){
library(Rcmdr)
} # cette fonction démarre le RC.
f4 <- function(...){
require(tcltk)
# on charge le package des interfaces graphiques.
exp <- tktoplevel(bg= "gray")
# création de la fenêtre 2 dans laquelle on mettra le texte qui donne des
#informations sur RC.
men<-tkmenu(exp)

56/71
# on crée une barre de menu dans la fenêtre 2.
tkconfigure(exp, menu = men)
# association fenêtre/menu.
winSearch <- function() {
string <- winDialogString("Search string", "")
RSiteSearch(string)
} # pour chercher par mots clés ou phrases dans la liste mailing du R-help, dans
#les archives et la documentation.
tkadd(men,"command",label = "Rechercher", command = winSearch)
# nous créons dans la barre de menu de la fenêtre 2 un bouton que nous appelons
#"Rechercher " et qui appellera la fonction "winSearch".
xscr <- tkscrollbar(exp, repeatinterval=5,orient="horizontal",
command=function(...)tkxview(txt,...))
# création du champ déroulant pour le texte.
yscr <- tkscrollbar(exp, repeatinterval=5,
command=function(...)tkyview(txt,...))
txt <- tktext(exp,bg="white",font="courier",

xscrollcommand=function(...)tkset(xscr,...),yscrollcommand=function(...)tkset(yscr,...
),wrap="none")
tkgrid(txt,yscr)
tkgrid(txt, xscr)
tkgrid.configure(yscr,sticky="ns")
tkgrid.configure(xscr,sticky="ew")
#le texte qui donne des détails sur la Rcmdr
tkinsert(txt,"end","Cette interface dénombre 37 opérations de calculs statistiques . .
. jusqu'à la fin du texte")
tkfocus(txt)
tktitle(exp)<-("Texte par la Société ARKESYS")
}
b1 <- tkbutton(tt,text='Démarrer l"interface statistique (RC), ici' ,font = "Courier",
width=50, command = f3)
b2 <- tkbutton(tt,text='En savoir plus sur R-Commander (RC), ici', font =
"Century",width=50,command = f4)
tkpack(b1,b2)
# Fin de l'exemple 1.
==================================================================

Exemple 2: Création d'une interface simple comportant uniquement deux boutons


"Ficher" et "Edition" dans une barre de menu, où chacun contient un menu. Dans
"Fichier" on démarrer l'interface R-Commander ou on ferme la fenêtre et avec "Edition"
on affiche un texte donnant des informations du RC.
Si l'on copie et colle l'exemple 2 (compris entre 2 lignes de "=") dans la CLI (ou dans
un script que l'on exécute), on doit avoir l'interface ci-dessous. Attention: l'exemple 2

57/71
utilise les fonctions f3 et f4 de l'exemple 1. Donc il faut exécuter au préalable l'exemple 1
pour que R reconnaisse f3 et f4.

============================================================
#Début de l'exemple 2: fenêtre avec une barre de menu "Fichier" et "Edition".
require(tcltk2)
require(tcltk)
fenetre <- tktoplevel()
tit2<-function(...){
tktitle(fenetre)<-("Démarrage de la R-C")
}
tit2(tt)
#ajout fonctionnalités sur Fichier Edition
LeMenu <- tk2menu(fenetre)
tkconfigure(fenetre, menu = LeMenu)
Fich <- tk2menu(LeMenu, tearoff = F)
Ferm <- tk2menu(Fich, tearoff = F)

tkadd(LeMenu,"cascade",label = "Fichier", menu = Fich)


tkadd(Fich,"command", label = "Démarrer RCmmander", command = f3)
tkadd(Fich,"cascade",label = "Fermer", menu = Ferm)

tkadd(Ferm,"command", label = "Fermer maintenant", command =


function()tkdestroy(fenetre))
tkadd(Ferm,"command", label = "Fermer plus tard", command =
function()tkdestroy(fenetre))
Edition <- tk2menu(LeMenu, tearoff = F)
tkadd(LeMenu,"cascade",label = "Edition", font = "Courier",menu = Edition)
tkadd(Edition, "command", label = "Plus sur la R-Commander", command = f4)
#tkadd(men,"command",label = "Rechercher", command = f3)
MasterFrame2 <- tkframe(fenetre)
tkgrid(MasterFrame2)
# Fin de l'exemple 2.
===========================================================

58/71
4 Conclusion
L'objectif principal du stage était l'établissement d'un manuel permettant à un
débutant avec le logiciel R d'effectuer des opérations de base, l'adapter en ajoutant de
nouvelles fonctionnalités, et savoir enfin quelle interface statistique choisir parmi celles
disponibles en libre-service sur Internet pour effectuer les opérations statistiques les
plus fréquentes et adapter cette dernière éventuellement.
Nos connaissances concernant le logiciel R, acquises à l'IUT2, sont bien limitées, la
société Arkesys a accepté de mettre à ma disposition tous les moyens nécessaires à un
travail de recherche afin de développer mes connaissances en autodidacte sur ce logiciel
pour éditer ce présent rapport (manuel) par la suite.
Dans la première partie de ce rapport, et qui a porté sur l'initiation de l'usager
débutant aux opérations de base, nous avons pu mettre en place, avec une démarche
didactique, une explication lui permettant de manipuler les nombres et effectuer les
opérations de base sur les matrices (liste exhaustive des opérateurs en langage R
disponible en Annexe II). Comme nous avons pu vaincre la difficulté de l'incompatibilité
du format R avec les autres formats ".txt", ".csv" et notamment ".xls". Nous avons en effet
montré dans le paragraphe 1.3 que des feuilles Excel peuvent être importées sous R
directement, sans les enregistrer sous un autre format au préalable, et que l'exportation
depuis R vers des feuilles Excel est aussi directe et aussi facile. Nous insistons sur
l'importance de ce point parce que, en général, la création des tables se fait avec des
tableurs comme Excel, plus commodes et plus malléables que langage R pour tout ce qui
est modification, sélection et extraction directes des valeurs. Comme ces tableurs sont
beaucoup plus largement diffusés que le logiciel R, ne pas avoir accès à ce format de
données enlève à R une grosse partie de sa notoriété en tant que logiciel de statistique,
d'où l'importance de montrer que des voies de communication avec ces formats tableurs
existent. Dans cette même partie, nous avons explicité l'essentiel de la manipulation des
tables.
La recherche des fonctions R et l'auto apprentissage est un point fondamental,
nous pensons avoir donné un aperçu suffisant pour que l'utilisateur puisse évoluer sur R
en autodidacte. Nous avons par ailleurs montré comment procéder pour un affichage
graphique sous R, une connaissance intrinsèquement liée à la manipulation des
nombres sous l'angle statistique. Une liste des opérations les plus courantes à propos
des packages R termine cette première partie.
La deuxième partie était orientée vers les opérations statistiques sous R. Les tests
que nous montrons dans cette partie sont les plus sollicités par les stagiaires d'Arkesys.
Donc le choix des points à expliquer et l'orientation de notre manuel à cet endroit sont
bien guidés par les exigences professionnelles plutôt que par l'intérêt général ou la
fréquence des tests étudiés. Nous avons pu mettre en évidence les démarches à suivre
pour réaliser une analyse de la variance, une régression linéaire simple et multiple. Sans
vouloir dresser la liste complète de tous les tests que ce document met à jour, nous
pouvons mentionner que dans cette partie il est possible de voir des exemples pour le
test de corrélation, le test de Student et l'intervalle de confiance sur une moyenne ou sur
l'égalité de deux moyennes, le test du Chi-deux, le test de normalité Shapiro-Wilk, le test
de Fisher pour la comparaison de deux variances, et le test de Bartlett sur l'homogénéité
des variances. R se montre à ce niveau plus simple que les tableurs et par conséquent
plus rapide pour la réalisation des tests statistiques.
Un deuxième thème abordé dans cette partie est l'algorithmique sous R. Bien
maîtriser ce domaine est indispensable dès que l'on commence à manipuler un grand
nombre de données où la recherche manuelle des valeurs devient extrêmement longue,
voir impossible à réaliser. Nous avons divisé notre recherche sur ce point en parties, la

59/71
première a porté sur les boucles classiques avec des instructions conditionnelles et
itératives et une deuxième laquelle a utilisé la première dans des fonctions et y a ajouté
des fenêtres pour saisir des paramètres qui sont traités par la fonction en question. Nous
sommes plutôt satisfaits du progrès que nous avons réalisé sur ce point parce que
maîtriser ce que nous présentons dans ce document témoigne d'un bon niveau en
algorithmique en langage R et permet un large panel de scénarios algorithmiques
possibles.
Le dernier paragraphe de cette partie était consacré aux interfaces statistiques
libres (gratuites) sous R. Notre recherche a révélé la présence de 4 interfaces qui sont
susceptibles d'intéresser la société Arkesys. La SciViews, malgré le fait qu'elle soit
conviviale et assez intuitive, connaît un problème majeur, c'est qu'elle n'est plus mise à
jour et elle ne tourne plus sous les versions les plus récentes des systèmes d'exploitation,
donc compter sur elle ne semble pas une bonne idée. L'interface R-Commander semble
être le meilleur compromis entre efficacité et simplicité, elle présente en effet les aspects
convivial et intuitif de la SciViews, mais contrairement à SciViews, elle est régulièrement
entretenue par John Fox de l'université McMaster. Donc l'interface que nous
recommandons pour le public de stagiaires d'Arkesys et pour tous les apprentis
statisticiens est R-Commander. Tinn-R est l'interface la plus complète parmi les 4 qui
ont fait l'objet de notre recherche, le fait qu'elle soit assez complète lui vaut d'être plus
complexe et par conséquent moins facilement accessible à un public qui n'est pas
professionnel des statistiques ou qui n'a tout simplement pas le temps d'apprendre à
piloter cette interface. Il faut savoir en effet naviguer entre 4 fenêtres qui ne
communiquent pas forcément entre elles. JGR (Java GUI for R) n'est pas vraiment
orientée vers les statistiques, elle offre plutôt de l'aide pour la programmation des
fonctions R, c'est par ce biais-là qu'elle peut être considérée comme une interface
statistique, puisqu'elle aide à la programmation des fonctions statistiques. Nous avons
été surpris par le temps que nécessite un tel type de recherche, en effet la recherche de
l'interface la plus adaptée est le thème qui a monopolisé la plus grosse partie du stage et
pourtant nous n'avons pas assez de description à fournir à propos de ces interfaces.
Nous jugeons notre documentation, sur ce point, insuffisante pour convaincre
l'utilisateur d'abandonner Tinn-R au profit de R-Commander, mais nous pensons qu'elle
passe bien le message et suffit pour engager notre responsabilité sur cette décision.
Un de nos objectifs était de sonder à quel point nous pouvons modifier l'interface
choisie pour l'adapter aux besoins spécifiques d'Arkesys. Nous avons pu constater, en
comprenant l'architecture algorithmique et la structuration interne de cette interface,
qu'il était effectivement possible d'apporter des modifications en ajoutant de nouvelles
fonctionnalités et en supprimant d'autres. Mais il nous a semblé que cette tâche
nécessite beaucoup de moyens, notamment en connaissances informatiques, et un
temps trop important pour que l'on puisse la réaliser pendant un stage de 10 semaines.
Nous avons finalement abandonné l'idée de modifier la R-Commander.
La troisième et dernière partie de ce document a porté sur l'adaptation de la R
Console et la création des fenêtres graphiques au démarrage de R. Nous avons en effet
pu comprendre comment procéder pour changer le profil de R donné par défaut. Nous
avons ainsi réussi à pénétrer son code source pour ajouter des boutons supplémentaires
dans la barre de menu. Des boutons que nous avons reliés à des fonctions que nous
avons écrites nous mêmes en langage R dans son code source pour que cela fasse une
partie intégrante du nouveau R après "reprofilement". Dans le deuxième paragraphe de
cette partie, nous avons montré que ces fonctions écrites en langage R, lues au
démarrage, peuvent être exécutées depuis des fenêtres indépendantes détachées de la R
Console, et que ces fenêtres peuvent évoluées vers des interfaces à part entière. C'est-à-
dire que l'exécution d'une fonction ne se limite pas à fournir un résultat, mais elle peut
être interactive en ouvrant une boîte de dialogue pour réclamer certains paramètres et
un paramètre peut en exiger un autre par une autre boîte de dialogue et ainsi de suite.

60/71
Enfin, ce stage était une véritable expérience dans le milieu professionnel où les
statistiques et informatique étaient au centre de notre travail. Les discussions avec
Monsieur T. Anthouard, formateur en statistiques et statisticien professionnel, étaient
très enrichissantes par les réponses qu'elles ont apportées à beaucoup de mes
interrogations. J'ai appris beaucoup sur le logiciel R, et j'espère que l'avenir professionnel
proche me donnera la chance de poursuivre mon apprentissage sur ce formidable outil
de statistiques.

61/71
Annexe I: Liste exhaustive des opérations offertes par R-Commander.
Ci-dessous la liste exclusive (intitulé en français) de toutes les opérations permises:
Fichier=> Sortir
From Commander
From Commander and R

Edition
Cut
Copy
Paste
Delete
Find...
Select all
Undo
Redo
Clear window

Données
New data set...
Load data set...

Données=>Importer
from text file, clipboard, or URL...
from SPSS data set...
from Minitab data set...
from STATA data set...
from Excel, Access or dBase data set...
Import data

Données=>lecture depuis packages


List data sets in packages
Read data set from an attached package...
Data in packages

Données=>données actives
Select active data set...
Refresh active data set
Help on active data set (if available)
Variables in active data set
Set case names...
Subset active data set...
Remove row(s) from active data set...
Stack variables in active data set...
Remove cases with missing data...
Save active data set...
Export active data set...
Active data set

Données=>gestion des variables dans données actives


Recode variables...
Compute new variable...
Add observation numbers to data set
Standardize variables...
Convert numeric variables to factors...

62/71
Bin numeric variable...
Reorder factor levels...
Define contrasts for a factor...
Rename variables...
Delete variables from data set ...
Manage variables in active data set
Data

Statistiques
Statistiques => Résumé
Active data set
Numerical summaries...
Frequency distributions...
Count missing observations
Table of statistics...
Correlation matrix...
Correlation test...
Shapiro-Wilk test of normality...

Statistiques => Table de contingence


Two-way table...
Multi-way table...
Enter and analyze two-way table...

Statistiques => Moyenne


Single-sample t-test...
Independent samples t-test...
Paired t-test...
One-way ANOVA...
Multi-way ANOVA...

Statistiques => Proportion


Single-sample proportion test...
Two-sample proportions test...

Statistiques => Variance


Two-variances F-test...
Bartlett's test...
Levene's test...

Statistiques => Tests non paramétriques


Two-sample Wilcoxon test...
Paired-samples Wilcoxon test...
Kruskal-Wallis test...
Friedman rank-sum test...

Statistiques => Analyse multivariée


Scale reliability...
Principal-components analysis...
Factor analysis...

Statistiques => Analyse multivariée =>Classification


k-means cluster analysis...
Hierarchical cluster analysis...
Summarize hierarchical clustering...
Add hierarchical clustering to data set...

63/71
Cluster analysis

Statistiques => Ajustement de modèles


Linear regression...
Linear model...
Generalized linear model...
Multinomial logit model...
Ordinal regression model...
Statistics
Summaries
Contingency tables
Means
Proportions
Variances
Nonparametric tests
Dimensional analysis
Fit models

Graphiques
Color palette...
Index plot...
Histogram...
Stem-and-leaf display...
Boxplot...
Quantile-comparison plot...
Scatterplot...
Scatterplot matrix...
Line graph...
XY conditioning plot...
Plot of means...
Strip chart...
Bar graph...
Pie chart...

Graphiques => 3D
3D scatterplot...
Identify observations with mouse
Save graph to file

Graphiques => Enregistrement


as bitmap...
as PDF/Postscript/EPS...
3D RGL graph...
Save graph to file
Graphs

Modèles
Select active model...
Summarize model
Add observation statistics to data...
Confidence intervals...
Akaike Information Criterion (AIC)
Bayesian Information Criterion (BIC)

Modèles=> Tests d'hypothèse


ANOVA table...

64/71
Compare two models...
Linear hypothesis...

Modèles=> Diagnostiques numériques


Variance-inflation factors
Breusch-Pagan test for heteroscedasticity.
Durbin-Watson test for autocorrelation...
RESET test for nonlinearity...
Bonferroni outlier test

Modèles=> Graphes (diagnostique)


Basic diagnostic plots
Residual quantile-comparison plot...
Component+residual plots
Added-variable plots
Influence plot
Effect plots
Models

Distributions
Distributions=>Continue
Distributions=>Continue=>Normale
Normal probabilities...
Plot normal distribution...
Sample from normal distribution...

Distributions=>Continue=>Student
t quantiles...
t probabilities...
Plot t distribution...
Sample from t distribution...

Distributions=>Continue=>Chi-deux
Chi-squared quantiles...
Chi-squared probabilities...
Plot chi-squared distribution...
Sample from chi-squared distribution...

Distributions=>Continue=>Fisher
F quantiles...
F probabilities...
Plot F distribution...
Sample from F distribution...

Distributions=>Continue=>Exponentiel
Exponential quantiles...
Exponential probabilities...
Plot exponential distribution...
Sample from exponential distribution...

Distributions=>Continue=>Uniforme
Uniform quantiles...
Uniform probabilities...
Plot uniform distribution...
Sample from uniform distribution...

65/71
Distributions=>Continue=>Bêta
Beta quantiles...
Beta probabilities...
Plot beta distribution...
Sample from beta distribution...

Distributions=>Continue=>Cauchy
Cauchy quantiles...
Cauchy probabilities...
Plot Cauchy distribution...
Sample from Cauchy distribution...

Distributions=>Continue=>Logistique
Logistic quantiles...
Logistic probabilities...
Plot logistic distribution...
Sample from logistic distribution...

Distributions=>Continue=>Lognormale
Lognormal quantiles...
Lognormal probabilities...
Plot lognormal distribution...
Sample from lognormal distribution...

Distributions=>Continue=>Gama
Gamma quantiles...
Gamma probabilities...
Plot gamma distribution...
Sample from gamma distribution...

Distributions=>Continue=>Weibull
Weibull quantiles...
Weibull probabilities...
Plot Weibull distribution...
Sample from Weibull distribution...

Distributions=>Continue=>Gumbel
Gumbel quantiles...
Gumbel probabilities...
Plot Gumbel distribution...
Sample from Gumbel distribution...

Distributions=>Discrète
Distributions=>Discrète=>Binomiale
Binomial quantiles...
Binomial tail probabilities...
Binomial probabilities...
Plot binomial distribution...
Sample from binomial distribution...

Distributions=>Discrète=>Poisson
Poisson quantiles...
Poisson tail probabilities...
Poisson probabilities...
Plot Poisson distribution...

66/71
Sample from Poisson distribution...

Distributions=>Discrète=>Geometric
Geometric quantiles...
Geometric tail probabilities...
Geometric probabilities...
Plot geometric distribution...
Sample from geometric distribution...

Distributions=>Discrète=> Hypergeometric
Hypergeometric quantiles...
Hypergeometric tail probabilities...
Hypergeometric probabilities...
Plot hypergeometric distribution...
Sample from hypergeometric distribution

Distributions=>Discrète=>Binomiale négative
Negative binomial quantiles...
Negative binomial tail probabilities...
Negative binomial probabilities...
Plot negative binomial distribution...
Sample from negative binomial distributi

Outils
Load package(s)...
Load Rcmdr plug-in(s)...
Options...
Tools

Aide
Commander help
Introduction to the R-Commander
Help on active data set (if available)
About Rcmdr
Help

67/71
Annexe II: Symboles des opérations mathématiques disponibles en R.
Ces symboles sont disponibles dans le package grDevices, pour les afficher:
help("plotmath").
Syntaxe Signification
x+y x plus y
x–y x minus y
x*y juxtapose x and y
x/y x forwardslash y
x %+-% y x plus or minus y
x %/% y x divided by y
x %*% y x times y
x %.% y x cdot y
x[i] x subscript i
x^2 x superscript 2
paste(x, y, z) juxtapose x, y, and z
Sqrt(x) square root of x
Sqrt(x, y) yth root of x
x == y x equals y
x != y x is not equal to y
x<y x is less than y
x <= y x is less than or equal to y
x>y x is greater than y
x >= y x is greater than or equal to y
x %~~% y x is approximately equal to y
x %=~% y x and y are congruent
x %==% y x is defined as y
x %prop% y x is proportional to y
plain(x) draw x in normal font
bold(x) draw x in bold font
italic(x) draw x in italic font
bolditalic(x) draw x in bolditalic font
symbol(x) draw x in symbol font
list(x, y, z) comma-separated list
... ellipsis (height varies)
cdots ellipsis (vertically centred)
ldots ellipsis (at baseline)
x %subset% y x is a proper subset of y
x %subseteq% y x is a subset of y

68/71
x %notsubset% y x is not a subset of y
x %supset% y x is a proper superset of y
x %supseteq% y x is a superset of y
x %in% y x is an element of y
x %notin% y x is not an element of y
hat(x) x with a circumflex
tilde(x) x with a tilde
dot(x) x with a dot
ring(x) x with a ring
bar(xy) xy with bar
widehat(xy) xy with a wide circumflex
widetilde(xy) xy with a wide tilde
x %<->% y x double-arrow y
x %->% y x right-arrow y
x %<-% y x left-arrow y
x %up% y x up-arrow y
x %down% y x down-arrow y
x %<=>% y x is equivalent to y
x %=>% y x implies y
x %<=% y y implies x
x %dblup% y x double-up-arrow y
x %dbldown% y x double-down-arrow y
alpha – omega Greek symbols
Alpha – Omega uppercase Greek symbols
theta1, phi1, sigma1, omega1 cursive Greek symbols
Upsilon1 capital upsilon with hook
aleph first letter of Hebrew alphabet
infinity infinity symbol
partialdiff partial differential symbol
nabla nabla, gradient symbol
32*degree 32 degrees
60*minute 60 minutes of angle
30*second 30 seconds of angle
displaystyle(x) draw x in normal size (extra spacing)
textstyle(x) draw x in normal size
scriptstyle(x) draw x in small size
scriptscriptstyle(x) draw x in very small size
underline(x) draw x underlined
x ~~ y put extra space between x and y

69/71
x + phantom(0) + y leave gap for "0", but don't draw it
x + over(1, phantom(0)) leave vertical gap for "0" (don't draw)
frac(x, y) x over y
over(x, y) x over y
atop(x, y) x over y (no horizontal bar)
sum(x[i], i==1, n) sum x[i] for i equals 1 to n
prod(plain(P)(X==x), x) product of P(X=x) for all values of x
integral(f(x)*dx, a, b) definite integral of f(x) wrt x
union(A[i], i==1, n) union of A[i] for i equals 1 to n
intersect(A[i], i==1, n) intersection of A[i]
lim(f(x), x %->% 0) limit of f(x) as x tends to 0
min(g(x), x > 0) minimum of g(x) for x greater than 0
inf(S) infimum of S
sup(S) Supremum of S
x^y + z normal operator precedence
x^(y + z) visible grouping of operands
x^{y + z} invisible grouping of operands
group("(",list(a, b),"]") specify left and right delimiters
bgroup("(",atop(x,y),")") use scalable delimiters
group(lceil, x, rceil) special delimiters

70/71