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)

1/71

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

2/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.

3/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.

4/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

5/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érations de base

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.

6/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 :

7/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

8/71

1.2.2 Manipulation

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.

9/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

10/71

1.3 Manipulation des tables

1.3.1 Importation et exportation des tables

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)

11/71

Pour éditer dans le but de changer les données.

fix(table.txt)

1.3.2 Manipulation

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.

12/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

13/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élective et exemple de requête SQL dans une table

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:

14/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

15/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.

16/71

1.3.4 Conversion des objets 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é

17/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")

18/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).

19/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)

20/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.

21/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.

22/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)

23/71

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

Figure 2. Exemple de graphique interactif sous R.

24/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.

25/71

2 Statistiques

2.1 Statistiques élémentaires sur R

2.1.1 Statistiques 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)

26/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 variance (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.

27/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.

28/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:

29/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

30/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égression linéaire

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).

31/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 statistiques

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:

32/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

33/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

34/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"

35/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)

36/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

37/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

38/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.

39/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érations sur les 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]]

40/71

[1] 100 [1] 100

2.1.7 Lois de probabilité 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)

41/71

2.2 Algorithmique

2.2.1 Exemple de boucles

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)

42/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 Exemple 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)

}

43/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)

44/71

summary(Z)

attach(Z)

PV<-p.value

if (PV>0.05){print("NON SIG")} else {print("SIG")}

45/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

46/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.

47/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.

48/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

messages

Fenêtre de

sortie

Fenêtre de

script

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

49/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.

50/71

2.3.4 JGR (Java GUI 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.

51/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.

52/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.

53/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. = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

54/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. = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

55/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.

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

56/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)

57/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

58/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.

===========================================================

59/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

60/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.

61/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.

62/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...

63/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...

64/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...

65/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...

66/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...

67/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

68/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

69/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

70/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