Faculté des Sciences et Techniques

MTH16205 : Logiciels de Statistique

Essomanda Tchandao Mangamana

Email : [email protected]

Année académique 2022-2023

Table des matières

1 Initiation au logiciel R 2
1.1 Présentation du logiciel R et RStudio . . . . . . . . . . . . . . . . . . 2
1.1.1 Téléchargement et installation de R . . . . . . . . . . . . . . . 2
1.1.2 Téléchargement et installation de RStudio . . . . . . . . . . . 3
1.1.3 Les menus et fenêtres de RStudio . . . . . . . . . . . . . . . . 3
1.2 Premières manipulations . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Principes généraux de R . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Création d'objets . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.4 Remarques sur la console de R . . . . . . . . . . . . . . . . . . 6
1.3 Quitter et sauvegarder sous le logiciel R . . . . . . . . . . . . . . . . 7
1.3.1 Quitter le logiciel R . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Sauvegarder sous le logiciel R . . . . . . . . . . . . . . . . . . 7
1.4 Données dans R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.1 Mode d'un objet . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4.2 Type d'un objet . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.3 Les vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4.4 Les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.4.5 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.4.6 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.4.7 Les tableaux de données . . . . . . . . . . . . . . . . . . . . . 23
1.4.8 Opérateurs mathématiques et logiques . . . . . . . . . . . . . 24
1.5 Quelques rappels sur les lois sous R . . . . . . . . . . . . . . . . . . . 26
1.6 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.6.1 Construction d'une nouvelle fonction . . . . . . . . . . . . . . 27
1.6.2 Boucles et vectorisation . . . . . . . . . . . . . . . . . . . . . 28
1.7 Les graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.7.1 Les fonctions graphiques . . . . . . . . . . . . . . . . . . . . . 30
1.7.2 Gestion de la fenêtre graphique . . . . . . . . . . . . . . . . . 41
1.7.3 Ajout des éléments au graphique . . . . . . . . . . . . . . . . 41
1.8 Racines, dérivation et intégration de fonctions . . . . . . . . . . . . . 43
1.8.1 Racines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.8.2 Dérivée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.8.3 Intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

1
Chapitre 1
Initiation au logiciel R

1.1 Présentation du logiciel R et RStudio

R est un langage de programmation interactif interprété et orienté objet qui

contient une très large collection de méthodes statistiques ainsi que des facilités gra-
phiques importantes. Il est initié dans les années 90 par Robert Gentleman et Ross
Ihaka, auxquels sont venus depuis s'ajouter de nombreux chercheurs. Aujourd'hui,
le logiciel R constitue un langage de programmation intégré d'analyses statistiques
telles que des statistiques descriptives (moyenne, médiane, ...), des tests d'hypo-
thèses, des régressions linéaires, des graphiques, etc.

Avantages
ˆ R est gratuit
ˆ R est multiplateforme (Linux, Mac OS X, Windows)
ˆ R est très puissant car les méthodes statistiques récentes sont rapidement dispo-
nibles
ˆ R dispose de beaucoup d'aide, d'informations et de forum à ce propos sur le web.

Inconvénients
ˆ Le logiciel et la documentation de base sont en anglais ;
ˆ R s'apparente davantage à un langage de programmation qu'à un logiciel propre-
ment dit.

1.1.1 Téléchargement et installation de R

Pour télécharger et installer R, il faut se rendre sur le site http ://www.r-
project.org/ et eectuer la démarche suivante :
ˆ Dans la rubrique Download, cliquer sur CRAN ;
ˆ Choisir un site miroir. Pour faire face au très grand nombre de téléchargements
du logiciel, un système de miroirs, le Comprehensive R Archive Network (CRAN)
https ://cran.r-project.org/, a été mis en place. Les mêmes chiers sont ainsi dis-
ponibles simultanément sur diérents serveurs situés à plusieurs endroits dans le

2
monde. Cette organisation présente au moins deux avantages majeurs : pouvoir
choisir un miroir proche de chez vous où que vous soyez dans le monde ou un miroir
de secours lorsque le miroir que vous avez l'habitude d'utiliser est indisponible ;
ˆ Choisir la version en fonction de votre système d'exploitation ;
ˆ Après le téléchargement, double-cliquer sur l'icône de R puis suivre les instructions
jusqu'à la n de l'installation.

1.1.2 Téléchargement et installation de RStudio

Une fois R correctement installé, rendez-vous sur http ://www.rstudio.com/products/rstudio ;
ˆ Choisir la version free de RStudio Desktop (Open Source Edition) ;
ˆ Cliquer sur download RStudio desktop ;
ˆ Choisir la version en fonction de votre système d'exploitation ;
ˆ Après le téléchargement, double-cliquer sur l'icône de RStudio et suivre les ins-
tructions d'installation.

1.1.3 Les menus et fenêtres de RStudio

Les menus
La description de quelques menus de RStudio est donnée dans le Tableau 1.1.

Table 1.1  Quelques menus de RStudio.

Menu Utilité
File et session gérer l'espace de travail, tels que la sélection du répertoire par dé-
faut, le chargement de chiers sources externes, la sauvegarde, etc.
Edit commandes de copier-coller et de recherche

Code et Debug développer et debugger des programmes

View personnaliser l'apparence de l'interface (acher ou de masquer la

barre d'outils et la barre de statut, etc.)

Plots gérer les fenêtre graphiques

Tools automatiser la gestion et le suivi des librairies (packages) de fonc-

tions, permettant leur installation et leur mise à jour

Help permet l'accès à l'aide en ligne et aux manuels de références de R

Les fenêtres
Parmi les fenêtres qui s'ouvrent quand on lance RStudio , on distingue en parti-
culier :

3
ˆ La console, fenêtre principale où sont exécutées les commandes et où apparaissent
les résultats.
ˆ L'éditeur de texte : fenêtre dans lequel on tapera les commandes. On peut ensuite
exécuter simplement les commandes dans la console en sélectionnant une ligne ou
un bloc de commandes, puis en cliquant sur run ou en tapant CTRL+Entrée. Ces
commandes sont alors copiées dans la console et exécutées.
ˆ Les fenêtres d'informations (historique des commandes, objets en mémoire, aide,
visualisation de chier, etc...).
ˆ Les fenêtres graphiques.

1.2 Premières manipulations

1.2.1 Principes généraux de R

R est une calculatrice

ˆ R permet de faire les opérations de calcul élémentaire (addition, soustraction,

multiplication, division, puissance, etc.)

> 3+5 # addition

[1] 8

> 3-5 # soustraction

[1] -2

> 3*5 # multiplication

[1] 15

> 3/5 # division

[1] 0.6

> 3^2 # ou 3**2 puissance

[1] 9

> 3*2-5*(2-4)/6

[1] 7.666667

ˆ R permet de faire des calculs plus élaborés en utilisant des fonctions (racine carrée,
logarithme népérien, arrondi, etc.)

> sqrt(4) # racine carrée

4
[1] 2

> log(2) # logarithme népérien

[1] 0.6931472

> round(2.6482, 2) # arrondi

[1] 2.65

ˆ R possède en mémoire la valeur de quelques constantes mathématiques, comme

la constante π qui est appelée par la commande pi.

> pi

[1] 3.141593

1.2.2 Création d'objets

On peut stocker en mémoire des données, des résultats, etc. Pour cela, on dénit
des objets R (on reviendra sur les diérents types d'objets), à l'aide des symboles
(<- ou ->) qui permettent d'assigner une valeur à un objet.

> a<-5;
> 3->b;
> c<-a+b;
Notez que R n'a pas aché les valeurs de a, b et c. Pour pouvoir les acher, il
faut écrire les noms de ces objets et de les exécuter :

> a;b;c

[1] 5

[1] 3

[1] 8

Toutefois, est possible d'acher directement le résultat d'une opération qui a été
aectée à un objet, sans pour autant saisir et exécuter le nom de cet objet. Pour
cela, il sut d'entourer cette instruction d'une paire de parenthèse.

> (a<-5); (3->b); (c<-a+b)

[1] 5

[1] 3

[1] 8

5
Pour nommer un objet, on peut utiliser les lettres minuscules "a-z" et majuscules
"A-Z", les chires 0-9, le point "." et le caractère de soulignement "_". Cependant il
faut toujours commencer par une lettre, éviter les lettres accentuées car elles risquent
de nuire à la portabilité du code. Les noms d'objets ne peuvent commencer par un
chire. S'ils commencent par un point, le second caractère ne peut être un chire.
Certains noms sont utilisés par le système R, aussi vaut-il mieux éviter de les utiliser.
En particulier, éviter d'utiliser c, q, t, C, D, I, di, length, mean, pi, range, var. La
liste des noms prédénis dans la bibliothèque de base peut être consultée ainsi :

> noms <- ls("package:base")

> length(noms)

[1] 1261

Exemple : Identier les noms valides des noms invalides : foo <- 5 ; foo.123 <-
5 ; foo_123 <- 5 ; 123foo <- 5 ; .foo <- 5 ; .123foo <- 5.

Attention, si un objet existe déjà et qu'une nouvelle valeur lui est assignée, la
valeur précédente est automatiquement écrasée. Ainsi, il peut être bon d'acher la
liste des objets utilisés. Ceci s'eectue au moyen de la commande ls.

1.2.3 Script
An de sauvegarder son travail ou de faire des rapports, il est utile de créer des
scripts. Il s'agit d'un chier texte contenant une succession de commandes R. Pour
créer et exécuter un script il faut suivre la procédure suivante :

ˆ Dans l'onglet File de RStudio, choisir New File puis R Script.

ˆ Enregistrer votre chier à l'emplacement de votre choix.
ˆ Taper directement vos commandes dans le script, puis de les exécuter dans la
console en utilisant la fonction Run. Pour sauvegarder un script, il sut, lorsque la
fenêtre de script est active, de sélectionner l'entrée "Sauver" du menu "Fichier".
Un élément clef d'une bonne écriture de script est la présence abondante de
commentaires. Ceux-ci se matérialisent par le symbole #. Ainsi, tout ce qui suit un
# est alors ignoré.

1.2.4 Remarques sur la console de R

1. Par défaut, les commandes sont en rouge et la réponse de R est en bleu.
2. Le chire 1 entre [ ] indique l'indice du premier élément de la ligne 1, le second
chire est le résultat de l'opération demandée.
3. R utilise le système anglo-saxon pour les nombres décimaux c'est-à-dire les déci-
males sont séparées par un point et non par une virgule. Exemple : Pour écrire un
virgule cinq sous R, on écrit 1.5 et non 1,5.
4. R distingue les majuscules des minuscules, c'est-à-dire que a et A ne désignent
pas le même objet. On dit que R est sensible à la casse.
5. Le point virgule est utilisé sous R, pour séparer deux instructions sur une même

6
ligne.
6. Pour rappeler les commandes déjà exécutées, on utilise la touche "Flèche vers le
haut".
7. Pour parcourir la ligne de commande active, en appuie sur les touches "Flèche
vers la gauche" et "Flèche vers la droite".

1.3 Quitter et sauvegarder sous le logiciel R

1.3.1 Quitter le logiciel R

Pour quitter R, vous utilisez la commande q().
La question Save workspace image ? [y/n/c] est posée (la question posée peut être en
anglais ou en français) : R propose de sauvegarder le travail eectué. Trois réponses
sont possibles :
ˆ y (pour yes) ou Sauver,
ˆ n (pour no) ou Ne pas sauver,
ˆ c (pour cancel) ou Annuler.
En tapant c ou en cliquant sur c, la procédure de n de session sous R est annulée. Si
vous tapez y ou si vous cliquez sur y, cela permet que les commandes tapées pendant
la session soient conservées en mémoire et soient donc "rappelables" (mais vous ne
pouvez pas les imprimer).

1.3.2 Sauvegarder sous le logiciel R

Si vous quittez R en choisissant la sauvegarde de l'espace de travail, deux chiers
sont créés :
1. le chier .Rdata contient des informations sur les variables utilisées,
2. le chier .Rhistory contient l'ensemble des commandes utilisées.

1.4 Données dans R

Les données se caractérisent par un type (vecteur, tableau, ...), un mode (numé-
rique, caractère, logique), une taille, une valeur et un nom.

1.4.1 Mode d'un objet

Les éléments stockés dans un objet peuvent être de diérents modes :
ˆ null (objet vide, exemple : NULL)
ˆ numeric (valeur numérique, exemple : 1, pi, 3.1416)
ˆ character (chaîne de caractères, exemple : "bonjour", "ko")
ˆ complex (nombre complexe, exemple : 2+1i, 5i)
ˆ logical (booléen, valeur logique, exemple : TRUE, FALSE, T, F).
Pour connaître le mode d'un objet x de R, il sut d'exécuter la commande mode (x).

> x<-pi;
> y<-"bonjour";

7
> z<-2+1i;
> l<- TRUE;
> mode(x);

[1] "numeric"

> mode(y);

[1] "character"

> mode(z);

[1] "complex"

> mode(l)

[1] "logical"

Il est aussi possible de tester l'appartenance d'un objet x à un mode particulier.

Le résultat est un booléen qui prend les valeurs TRUE ou FALSE.

> x <-1
> is.null(x); is.logical(x); is.numeric(x); is.complex(x); is.character(x)

[1] FALSE

[1] FALSE

[1] TRUE

[1] FALSE

[1] FALSE

Il est possible de convertir un objet x d'un mode à un autre de façon explicite

grâce aux commandes : as.logical(x) ; as.numeric(x) ; as.complex(x) ; as.character(x).
Il faut cependant être prudent quant à la signication de ces conversions. R
retourne toujours un résultat à une instruction de conversion même si cette dernière
n'a pas de sens. A titre indicatif, nous avons le tableau de conversion suivant :

8
 Table 1.2  Tableau de conversion d'un mode à un autre.
De en Fonction Coversions
FALSE→ 0
logique numérique as.numeric
TRUE→ 1
FALSE→ "FALSE"
logique caractère as.character
TRUE→ "TRUE"

"1", "2", ...→ 1, 2, ...

caractère numérique as.numeric
"A"→ NA

"FALSE", "F"→ FALSE

caractère logique as.logical "TRUE", "T" → TRUE
autres caractères → NA

0→ FALSE
numérique logique as.logical
autres nombres → TRUE

numérique caractère as.character 1, 2, ...→ "1" , "2", ...

La taille d'un objet est le nombre d'éléments qu'il contient. Elle s'obtient à l'aide
de la fonction length.

> x<- 5; length(x)

[1] 1

Valeurs manquantes, innies et indéterminées

Pour diérentes raisons, il se peut que certaines données ne soient pas collectées
lors d'une expérience. On parle alors de données manquantes. Dans R, une valeur
manquante est représentée par NA (Not Available). Par défaut, le mode de NA est
logical, mais NA ne peut être considéré ni comme TRUE, ni comme FALSE.
Toute opération impliquant une donnée NA a comme résultat NA.

> x<-NA
> x+1

[1] NA

Certaines fonctions (sum, mean, par exemple) ont par conséquent un argument na.rm
qui, lorsque TRUE, élimine les données manquantes avant de faire un calcul.

> x<-c(2, 5, 8, NA)

> sum(x)

9
[1] NA
> mean(x)
[1] NA
> sum(x, na.rm=TRUE)
[1] 15
> mean(x, na.rm=TRUE)
[1] 5
La valeur NA n'est égale à aucune autre, pas même elle-même (selon la règle ci-
dessus, le résultat de la comparaison est NA) :
> NA == NA
[1] NA
Pour savoir où se trouvent les valeurs manquantes d'un objet x, on pose la question :
is.na(x). Ceci retourne un booléen de même longueur que x. La question est posée
élément par élément. Dans le cas d'un vecteur, cela renvoie un vecteur logique de
même longueur que x avec TRUE si l'élément correspondant de x est NA et FALSE
sinon.

> x<-c(2, 5, 8, NA)

> is.na(x)
[1] FALSE FALSE FALSE TRUE
R représente correctement les valeurs innies avec Inf pour +∞ et -Inf pour −∞.
> x<- exp(1e10); x
[1] Inf
> y<-1/0; y
[1] Inf
> z<--1/0; z
[1] -Inf
R représente les valeurs qui ne sont pas des nombres (formes indéterminées) par
NaN (Not A Number) :

> y<-1/0; y-y

[1] NaN
> log(-2)
[1] NaN
Ces valeurs sont testées avec les fonctions is.innite, is.nite et is.nan.

10
1.4.2 Type d'un objet
Les données manipulées par R peuvent être de diérents types :
ˆ un vecteur (vector) : suite d'éléments à une dimension
ˆ une matrice (matrix) : suite d'éléments à 2 dimensions
ˆ un tableau (array) : suite d'éléments à k dimensions
ˆ un facteur (factor) : suite d'éléments catégoriels avec les diérents niveaux possibles
ˆ un tableau de données (data.frame) : ensemble de vecteurs de même longueur
ˆ une liste (list) : peut contenir n'importe quel type d'objet
ˆ série temporelle (time series).

1.4.3 Les vecteurs

L'objet de base en R est le vecteur. Il est composé d'un ensemble de valeurs
toutes du même mode (numérique, logique, chaîne de caractères, etc.). La longueur,
obtenue avec la fonction length donne le nombre d'éléments du vecteur.

Les vecteurs numériques

Pour construire un vecteur, diérentes méthodes sont possibles dont voici les
principales :
ˆ Construction par la fonction collecteur c.

> v<-c(2, 5, 7, 9); v; c(v,-3)

[1] 2 5 7 9

[1] 2 5 7 9 -3

Il est possible (et souvent souhaitable) de donner une étiquette à chacun des éléments
d'un vecteur.

> v<-c(2, 5, 7, 9);

> names(v) <- c("a", "b", "c", "d"); v

a b c d
2 5 7 9

> v<-c(a=2, b=5, c=7, d=9); v

a b c d
2 5 7 9

ˆ Construction par l'opérateur :.

> 1:6; 9:1

11
[1] 1 2 3 4 5 6

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

ˆ Construction par la fonction seq.

> seq(1,6,by=0.5); seq(1,6,length=5)

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0

[1] 1.00 2.25 3.50 4.75 6.00

ˆ Construction par la fonction rep.

> rep(1, 4); rep(c(1,2), each=3)

[1] 1 1 1 1

[1] 1 1 1 2 2 2

ˆ Construction par la fonction scan. R demande alors d'entrer les éléments au fur
et à mesure. Avec l'argument n=5, on précise que 5 éléments seront collectés. Si on
ne précise pas n, on arrête de collecter en mettant une valeur vide.

> scan(n=5)

Les vecteurs de caractères

Il est possible de créer des vecteurs de caractères de la même façon en utilisant
les fonctions c ou rep.

> c("Koffi", "Ama"); rep('A', 5); rep(c('a','b'),c(2,7))

[1] "Koffi" "Ama"

[1] "A" "A" "A" "A" "A"

[1] "a" "a" "b" "b" "b" "b" "b" "b" "b"

12
Les vecteurs logiques
Les vecteurs de booléens sont en général générés grâce à des opérations logiques :
">", ">=", "<", "<=", "==", " !=", etc. Ils peuvent aussi être générés par les
fonctions c ; rep ou seq. Ils permettent des sélections complexes ou des opérations
de conditions.

> 1>0

[1] TRUE

Cette commande retourne un vecteur logique de longueur 1 qui est TRUE, puisque
1 est plus grand que 0. La commande

> x>3
retourne un vecteur logique de même longueur que x. Ses éléments ont la valeur
TRUE quand l'élément correspondant satisfait la condition et FALSE sinon. Lors
d'opérations arithmétiques, les logiques sont transformés en numériques avec la
convention que les FALSE sont transformés en 0 et les TRUE en 1.

> x<-c(-1, 0, 2)
> x>1

[1] FALSE FALSE TRUE

> (1+x^2)*(x>1)

[1] 0 0 5

On peut aussi utiliser les fonctions all ou any. La fonction all renvoie TRUE si tous
les éléments satisfont la condition et FALSE sinon. La fonction any renvoie TRUE
dès que l'un des éléments satisfait la condition, FALSE sinon.

> all(x>1)

[1] FALSE

> any(x>1)

[1] TRUE

Remarque
Si l'on mélange dans un même vecteur des objets de mode diérents, il y a conver-
sion automatique vers le mode pour lequel il y a le moins de perte d'information,
c'est-à-dire vers le mode qui permet le mieux de retrouver la valeur originale des
éléments.

> c(5, TRUE, FALSE) # conversion en mode numérique

13
[1] 5 1 0

> c(5, "z") # conversion en mode caractère

[1] "5" "z"

> c(TRUE, "z") # conversion en mode caractère

[1] "TRUE" "z"

> c(5, TRUE, "z") # conversion en mode caractère

[1] "5" "TRUE" "z"

Sélection d'une partie d'un vecteur

On peut sélectionner une partie des éléments d'un vecteur en utilisant les crochets
[ ] et en spéciant le vecteur d'indices ou de noms des termes qui nous intéressent.
L'intérêt de la sélection est soit d'extraire des éléments d'un objet x avec la construc-
tion x[i], ou de les remplacer avec la construction x[i] < −y . Il existe cinq façons de
sélectionner une partie d'un vecteur dans R.
ˆ Sélection avec un vecteur d'entiers positifs. Les éléments se trouvant aux po-
sitions correspondant aux entiers sont extraits du vecteur, dans l'ordre. C'est la
technique la plus courante.

> x <- c(A = 2, B = 4, C = -1, D = -5, E = 8); x[c(1, 3)]

A C
2 -1

ˆ Sélection avec un vecteur d'entiers négatifs. Les éléments se trouvant aux po-
sitions correspondant aux entiers négatifs sont alors éliminés du vecteur.

> x[c(-2, -3)]

A D E
2 -5 8

ˆ Sélection avec un vecteur booléen. Le vecteur d'indices doit alors être de la

même longueur que le vecteur de sélection. Les éléments correspondant à une valeur
TRUE sont extraits du vecteur, alors que ceux correspondant à FALSE sont éliminés.

> x > 0; x[x > 0]

A B C D E
TRUE TRUE FALSE FALSE TRUE

A B E
2 4 8

14
 ˆ Sélection avec un vecteur de chaînes de caractères. Utile pour extraire les
éléments d'un vecteur à condition que ceux-ci soient nommés :

> x[c("B", "D")]

B D
4 -5

ˆ L'indice est laissé vide. Tous les éléments du vecteur sont alors sélectionnés.

> x[ ]

A B C D E
2 4 -1 -5 8

Cas pratiques de sélection

Nous pouvons substituer à un sous-ensemble sélectionné des valeurs nouvelles :

> x<- c(1,5,NA,8,NA,NA); x

[1] 1 5 NA 8 NA NA

> x[is.na(x)] <- 0 ; x # les NA de x reçoivent la valeur 0

[1] 1 5 0 8 0 0

> y<- c(1,-5,0,8,-2); y

[1] 1 -5 0 8 -2

> y[y<0] <- -y[y<0] # ou abs(y)

> # remplace les éléments négatifs par leurs opposés

Opérations sur les vecteurs

Les opérations +, *, - et / entre 2 vecteurs de même dimension sont des opérations
terme à terme. Si les vecteurs ne sont pas de même longueur, le plus court est
complété automatiquement.

> v <- 1:12

> v + 2

[1] 3 4 5 6 7 8 9 10 11 12 13 14

> v * -12:-1

[1] -12 -22 -30 -36 -40 -42 -42 -40 -36 -30 -22 -12

> v + 1:3

15
 [1] 2 4 6 5 7 9 8 10 12 11 13 15

Les opérateurs de comparaison s'appliquent à deux objets de n'importe quel

mode et retournent une valeur logique. En fait les opérateurs opèrent sur chaque
élément des objets comparés et retourne donc un objet logique de même taille.

> x <- 1:10; y <- (-3:6)^2; x <= y

[1] TRUE TRUE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE

> x <- seq(2, 10, by = 2); y <- 2 * (1:5); x == y

[1] TRUE TRUE TRUE TRUE TRUE

1.4.4 Les matrices

Les matrices, comme les vecteurs, sont de mode quelconque, mais elles ne peuvent
pas contenir des éléments de nature diérente (c'est à dire qu'une matrice ne peut
pas contenir des valeurs numériques et du texte par exemple). Chaque valeur de la
matrice peut être repérée par son numéro de ligne et de colonne. Une matrice peut
être créée à partir de plusieurs fonctions.
ˆ Usage de la function matrix.
matrix(vec,nrow=n,ncol=p,byrow=T) où vec est le vecteur contenant les éléments
de la matrice, qui seront rangés en colonne (sauf si l'option byrow=T est choisie).
Cette matrice contient n lignes et p colonnes.
> A=matrix(1:9, nrow=3, ncol=3, byrow=T); A

[,1] [,2] [,3]

[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9

ˆ Usage de la function rbind.

> rbind(1:3,4:6,7:9)

[,1] [,2] [,3]

[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9

ˆ Usage de la function cbind.

> cbind(seq(1,7,by=3),seq(2,8,by=3),seq(3,9,by=3))

[,1] [,2] [,3]

[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9

16
 On a la possibilité d'attribuer des noms aux lignes et aux colonnes d'une matrice
via l'option dimnames (ces noms doivent être de type character) ou rownames et
colnames, respectivement.

> dimnames(A)<-list(c("ind 1", "ind 2", "ind 3"), c("var 1", "var 2", "var 3"));

var 1 var 2 var 3

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

> rownames(A)<- c("ind 1", "ind 2", "ind 3")

> colnames(A)<- c("var 1", "var 2", "var 3")

Pour connaître les dimensions d'une matrice, on utilise la fonction dim. La longueur
length d'une matrice donne le nombre total d'éléments de cette matrice et le mode
mode, correspond au mode des éléments de cette matrice.

> dim(A)

[1] 3 3

> length(A)

[1] 9

> mode(A)

[1] "numeric"

Sélection d'éléments ou d'une partie d'une matrice

Comme pour les vecteurs, la sélection d'éléments ou d'une partie d'une matrice
se fait à l'aide des crochets [ ]. Pour sélectionner l'élément (i, j) de la matrice A, il
faut écrire A[i,j]. Il est rare qu'on ait besoin de ne sélectionner qu'un seul élément
dans une matrice. Usuellement, on sélectionne une ou plusieurs lignes et/ou une ou
plusieurs colonnes. Voyons les diérents cas rencontrés en pratique :
ˆ Sélection par des entiers positifs.

A[i,] retourne la ligne i sous la forme d'un vecteur. Pour la ligne i sous la forme
d'une matrice uniligne et non plus d'un vecteur, on utilise A[idrop=F]. Ce qui
permet de conserver le nom de la ligne.
A[,j] retourne la colonne j sous la forme d'un vecteur. De même, pour conserver le
nom de la colonne, on utilise l'argument drop : A[,j,drop=F].
Pour sélectionner plusieurs lignes ou colonnes, on utilise l'opérateur : pour recueillir
les indices de ces lignes ou colonnes (si elles sont contiguës) et le collecteur c (si elles
ne sont pas contiguës).

17
> A[2,3] # sélection de l'élément à la ligne 2 et colonne 3 de A

[1] 6

> A[1,] # sélection de la première ligne de A

var 1 var 2 var 3

1 2 3

> A[1,,drop=F] # sélection de la première ligne de A et conservation de nom

var 1 var 2 var 3

ind 1 1 2 3

> A[,3] # sélection de la troisième colonne de A

ind 1 ind 2 ind 3

3 6 9

> A[,3,drop=F] # sélection de la troisième colonne de A et conservation de nom

var 3
ind 1 3
ind 2 6
ind 3 9

> A[1:2,]

var 1 var 2 var 3

ind 1 1 2 3
ind 2 4 5 6

> A[c(1, 3),]

var 1 var 2 var 3

ind 1 1 2 3
ind 3 7 8 9

ˆ Sélection par des entiers négatifs.

A[-i,-j] donne la matrice A sans sa ième ligne et jème colonne.
A[-i,] donne la matrice A sans sa ième ligne.
A[,-j] donne la matrice A sans sa jème colonne.

> A[-1,] # suppression de la première ligne de A

var 1 var 2 var 3

ind 2 4 5 6
ind 3 7 8 9

> A[,-2] # suppression de la deuxième colonne de A

18
 var 1 var 3
ind 1 1 3
ind 2 4 6
ind 3 7 9

> A[-1,-3] # suppression de la première ligne et troisième colonne de A

var 1 var 2
ind 2 4 5
ind 3 7 8

ˆ Sélection par des logiques.

Soit la matrice m suivante :

> m<-matrix(1:8, ncol=4, byrow=T)

Pour obtenir uniquement les colonnes de m pour lesquelles la valeur sur la pre-
mière ligne est strictement supérieure à 2, on écrit :

> m<-matrix(1:8, ncol=4, byrow=T)

> m[,m[1,]>2]

[,1] [,2]
[1,] 3 4
[2,] 7 8

C'est donc une matrice, alors que l'instruction suivante retourne un vecteur conte-
nant les valeurs de m supérieures à 2 :

> m[m>2]

[1] 5 6 3 7 4 8

Pour remplacer les valeurs de m supérieures à 2 par des NA, on utilise la commande

> m[m>2]<-NA; m

[,1] [,2] [,3] [,4]

[1,] 1 2 NA NA
[2,] NA NA NA NA

Opérations sur les matrices

Les opérations +, *, - et / entre 2 matrices de même dimension sont des opéra-
tions terme à terme.
R ore des facilités pour le calcul matriciel. En voici quelques unes :

19
 Table 1.3  Fonctions utiles en calcul matriciel.
Fonction Description
A%*%B produit de deux matrices A et B
t(A) transposée de A

crossprod(A, B) produit croisé t(A)%*%B

tcrossprod(A, B) produit croisé A%*%t(B)

det(A) déterminant de A

diag(A) extrait la diagonale d'une matrice A et renvoie un vec-

teur ou crée une matrice diagonale de diagonale A

solve(A) matrice inverse de A

solve(A,b) résout le système linéaire Ax = b

eigen(A) calcule les valeurs et vecteurs propres de A

svd(A) décomposition en valeurs singulières de A

chol(A) décomposition de Cholesky de A

qr(A) décomposition QR de A

dim(A), nrow(A), ncol(A) dimension, nombre de lignes, nombre de colonnes de A

rowSums(A), colSums(A) sommes par ligne, somme par colonne

rowMeans(A), colMeans(A) moyenne par ligne, moyenne par colonne.

> A <- matrix(1:4, 2); A

[,1] [,2]
[1,] 1 3
[2,] 2 4

> B <- matrix(c(5, 7, 6, 8), 2); B

[,1] [,2]
[1,] 5 6
[2,] 7 8

> 5 * A

20
 [,1] [,2]
[1,] 5 15
[2,] 10 20

> A + B

[,1] [,2]
[1,] 6 9
[2,] 9 12

> A * B

[,1] [,2]
[1,] 5 18
[2,] 14 32

> A / B

[,1] [,2]
[1,] 0.2000000 0.5
[2,] 0.2857143 0.5

> A * c(2, 3)

[,1] [,2]
[1,] 2 6
[2,] 6 12

> D <- A %*% t(B); D

[,1] [,2]
[1,] 23 31
[2,] 34 46

> eig <- eigen(D); eig

eigen() decomposition
$values
[1] 68.9419802 0.0580198

$vectors
[,1] [,2]
[1,] -0.5593385 -0.8038173
[2,] -0.8289393 0.5948762

La fonction eigen retourne les valeurs propres dans l'objet values et les vecteurs
propres dans l'objet vectors. Si on veut extraire le premier vecteur propre, il sut
d'écrire :

21
> eig$vectors[,1]
[1] -0.5593385 -0.8289393

23x + 31y = 1
Pour résoudre le système d'équations suivant : A =
34x + 46y = 2
qui revient à écrire Dz = V , avec V = c(1, 2), on utilise la fonction solve :
> V=c(1, 2)
> solve(D,V)
[1] -4 3
Les solutions sont donc x = −4 et y = 3.
La fonction apply permet d'appliquer une fonction f aux lignes (MARGIN=1)
ou aux colonnes (MARGIN=2) de la matrice.
> A=matrix(1:6, ncol=3); A
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
> apply(A, MARGIN=2, sum) # sommes par colonne
[1] 3 7 11
> apply(A, 1, mean) # moyennes par lignes
[1] 3 4

1.4.5 Les tableaux

La généralisation d'une matrice à plus de deux dimensions est un tableau (array).
Le nombre de dimensions du tableau est toujours égal à la longueur de l'attribut
dim. La fonction de base pour créer des tableaux est array.
> array(1:24, dim = c(3, 4, 2))
, , 1

[,1] [,2] [,3] [,4]

[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12

, , 2

[,1] [,2] [,3] [,4]

[1,] 13 16 19 22
[2,] 14 17 20 23
[3,] 15 18 21 24
Comme pour les vecteurs et les matrices, la sélection des éléments des tableaux se
fait avec les crochets [ ].

22
1.4.6 Les listes
La liste est un objet hétérogène. C'est un ensemble ordonné d'objets qui n'ont
pas toujours même mode ou même longueur. Les objets sont appelés composantes
de la liste. Ces composantes peuvent avoir un nom. La fonction de base pour créer
des listes est list.

> x <- list(size = c(1, 5, 2), user = "Joe", new = TRUE)

La liste demeure un vecteur. On peut donc extraire ses éléments avec l'opérateur [
]. Cependant, cela retourne une liste contenant le ou les éléments sélectionnés. C'est
rarement ce que l'on souhaite.
Pour extraire un élément d'une liste et n'obtenir que cet élément, et non une liste
contenant l'élément, il faut utiliser l'opérateur [[ ]].

> x[1]

$size
[1] 1 5 2

> x[[1]]

[1] 1 5 2

Une autre (la meilleure, en fait) façon d'extraire un seul élément d'une liste est par
son étiquette avec l'opérateur $.

> x$size

[1] 1 5 2

1.4.7 Les tableaux de données

Les tableaux de données (data frames) sont des listes particulières dont les com-
posantes sont de même longueur, mais les modes peuvent être diérents. Un data
frame est généralement représenté sous la forme d'un tableau à deux dimensions.
Chaque élément de la liste sous-jacente correspond à une colonne.
On crée un data frame avec la fonction data.frame.

> vec1 <- 1:5; vec1

[1] 1 2 3 4 5

> vec2 <- c("a", "b", "c", "d", "d"); vec2

[1] "a" "b" "c" "d" "d"

> df <-data.frame(nom.var1=vec1, nom.var2=vec2); df

23
 nom.var1 nom.var2
1 1 a
2 2 b
3 3 c
4 4 d
5 5 d

Un data frame peut être indicé à la fois comme une liste et comme une matrice.
Pour convertir un autre type en data frame, on utilise la fonction as.data.frame.
Les fonctions rbind et cbind peuvent être utilisées pour ajouter des lignes ou
des colonnes à un data frame. On peut rendre les colonnes d'un data frame (ou d'une
liste) visibles dans l'espace de travail avec la fonction attach, puis les masquer avec
detach.

Quelques fonctions utiles pour la manipulation des tableaux

de données

Table 1.4  Fonctions utiles pour la manipulation des tableaux de données

sqrt, abs racine carrée, valeur absolue
sin, cos, tan sinus, cosinus, tangente
exp, log, log10 exponentiel, logarithme naturel, logarithm à base 10
sum, prod, mean somme, produit, moyenne
var, sd variance, écart type
min, max minimum, maximum
length, nrow, ncol longueur, nombre de lignes, nombre de colonnes
cumsum, cumprod sommes cumulées, produits cumulés
which.min, which.max, which retourne les positions
sort trie les éléments dans l'ordre croissant

1.4.8 Opérateurs mathématiques et logiques

Le tableau ci-dessous présente les opérateurs mathématiques et logiques les plus
fréquemment employés, en ordre décroissant de priorité des opérations. Le tableau
contient également les opérateurs d'assignation et d'extraction ; il est utile de connaître
leur niveau de priorité dans les expressions R. Les opérateurs de puissance () et
d'assignation à gauche (< −, << −) sont évalués de droite à gauche ; tous les autres
de gauche à droite. Ainsi, 223 est 28, et non 43.

24
Table 1.5  Principaux opérateurs du langage R, en ordre décroissant de priorité
Opérateur Fonction
$ Extraction
 Puissance

: Génération de suite

%*%, %%, %/% Produit matriciel, modulo, division entière

*, / Multiplication, division

+, - Addition, soustraction

Plus petit, plus petit ou égal, égal,

<, <=, ==, >=, >, !=
plus grand ou égal,plus grand, diérent de

! Négation logique

&, && "Et" logique

|, || "Ou" logique

− >, − >> Assignation

< −, << − Assignation

> 5 %% 2

[1] 1

> 5 %% 1:5

[1] 0 1 2 1 0

> 10 %% 1:15

[1] 0 0 1 2 0 4 3 2 1 0 10 10 10 10 10

> 5 %/% 1:5

[1] 5 2 1 1 1

> 10 %/% 1:15

[1] 10 5 3 2 2 1 1 1 1 1 0 0 0 0 0

25
1.5 Quelques rappels sur les lois sous R

Lois usuelles et génération de données aléatoires

Le logiciel R permet d'eectuer des calculs avec toutes les lois de probabilité
usuelles, et aussi de simuler des échantillons issus de ces lois. Le tableau suivant
résume les diérentes lois implémentées dans R.

Table 1.6  Diérentes lois de probabilité implémentées dans R

Loi appellation R Arguments
bêta beta forme 1, forme 2
binomiale binom size, prob

chi deux chisq df (degrés de liberté)

uniforme unif min, max

exponentielle exp rate

Fisher f df1, df2

gamma gamma forme, echelle

géometrique geom prob

hypergéometrique hyper m, n, k (taille échantillon)

binomiale négative nbinom size, prob

normale norm mean, sd

Poisson pois lambda

Student t df

Weibull weibull forme, échelle

Pour certaines lois, les paramètres ont des valeurs par défaut : parmi les plus
utilisées, la loi uniforme porte sur l'intervalle [0,1] et la loi normale est centrée
réduite.
Pour eectuer un calcul avec une de ces lois, il sut d'utiliser comme fonction
l'une des appellations R ci-dessus avec le préxe d pour une densité, p pour proba-
bilité, q pour quantile et r pour random. Ainsi :
dnorm() représente la fonction de densité de probabilité de la loi normale.
pnorm() représente la fonction de répartition de la loi normale.

26
qnorm() représente la fonction réciproque de la fonction de répartition de la loi nor-
male.
rnorm() représente la fonction permettant de faire des tirages aléatoires selon une
loi normale.

Nom des arguments : x, q, p n

Le premier argument des fonctions xxx est toujours nommé de la façon suivante :
dxxx(x) où x représente un vecteur de valeurs possibles pour une variable aléatoire
suivant la loi xxx. Il peut être réduit à une seule valeur.
pxxx(q) où q représente un (ou un vecteur) de valeur(s) de quantile(s).
qxxx(p) où p représente une (ou un vecteur) de probabilités.
rxxx(n) où n représente un entier, indiquant le nombre total de tirages aléatoire
voulu.
Avec ces notations on met bien en évidence les fonctions réciproques. On a par
exemple : qxxx(pxxx(q)) = q.

Quelques exemples
ˆ La commande dbinom(x=3, 10, 0.3) renvoie P (Y = 3) où Y suit une Binomiale
de paramètre n = 10 et p = 0.3. On peut aussi se contenter de taper dbinom(3, 10,
0.3).
ˆ pbinom(3, 10, 0.3) renvoie P (Y ≤ 3) où Y suit une Binomiale de paramètre n = 10
et p = 0.3.
ˆ qbinom(0.6,10,0.3) renvoie le plus petit entier k tel que P (Y ≤ k) ≥ 0.6. C'est-à-
dire 3 ici.
ˆ Si l'on tape : a=dpois(x=0 :30,lambda=3), on obtient un vecteur a 31 coordonnées
dont la ième contient la valeur P (X = i) où X est une v.a qui suit un loi de Poisson
de paramètre λ = 3.
ˆ runif(10,0,20) renvoie 10 valeurs tirées selon la loi uniforme sur l'intervalle [0 ; 20].
ˆ pnorm(3) renvoie P (Z ≤ 3) où Z suit une N (0; 1). On peut également taper
pnorm(3,mean=0,sd=1) ou pnorm(3,0,1) ou encore pnorm(q=3,mean=0,sd=1).
ˆ Pour une loi normale générale, la commande pnorm(q=9,mean=5,sd=2) ren-
voie P (X ≤ 9) où X suit une N (5; 2). La encore, on peut se contenter de taper
pnorm(9,5,2).
ˆ La commande plot(dnorm(x=20 :100,mean=60,sd=10)) vous renvoie l'allure dis-
crétisée de la densité d'une N (60; 10).
ˆ La commande qchisq(0.9, 5) vous renvoie le nombre z (quantile d'un χ2 à 5 ddl)
tel que P (X < z) = 0.9, où X suit χ2 (5).

1.6 Les fonctions

1.6.1 Construction d'une nouvelle fonction

De manière générale, la dénition d'une nouvelle fonction passe par l'expression
suivante : NomFonction=function(arg1[=expr1],arg2[=expr2],...){

27
Bloc d'instructions
}
NomFonction est le nom de la fonction (les règles pour les noms de fonctions
étant les mêmes que celles présentées ci-dessus pour tout autre objet). Les accolades
signalent le début et la n du code source de la fonction ainsi dénie, tandis que
les crochets ne font pas partie de l'expression mais indiquent le caractère facultatif
des valeurs par défaut des arguments. Pour une fonction donnée, la liste de ses
arguments (avec les valeurs par défaut éventuelles) est donnée par la fonction args.
Les arguments des fonctions peuvent être abrégés (tant que l'abréviation n'est pas
ambiguë).
Bloc d'instructions est le corps de la fonction, c'est soit une instruction ou un
groupe d'instructions. Dans le cas d'un groupe d'instructions, deux instructions suc-
cessives sont séparées par un retour à la ligne (touche entrée) ou sont conservées sur
une même ligne mais en les séparant par un point-virgule.
Lors de l'exécution, R renvoie par défaut le résultat de la dernière expression
évaluée dans la fonction. On évitera donc que la dernière expression soit une aecta-
tion, car la fonction ne retournera alors rien et on ne pourra utiliser une construction
de la forme x < −f () pour aecter le résultat de la fonction à une variable.
Si on doit retourner un résultat sans être à la dernière ligne de la fonction (à l'inté-
rieur d'un bloc conditionnel, par exemple), on utilise la fonction return. L'utilisation
de return à la toute n d'une fonction est tout à fait inutile et considérée comme
du mauvais style en R.
Lorsqu'une fonction doit retourner plusieurs résultats, il est en général préférable
d'avoir recours à une liste nommée.

> carre=function(x) x^2

> carre(2)

[1] 4

1.6.2 Boucles et vectorisation

Boucles
Boucles for
Nous souhaitons acher tous les entiers de 1 à 99 à l'écran. Une solution est la
suivante :

> for (i in 1:99)

+ print(i)
L'indice i prend comme valeurs toutes les coordonnées du vecteur choisi. De manière
générale, la boucle for s'écrit :

> for (i in vecteur){

+ expr1

28
+ expr2
+ ...
+ }

Boucles while
Une autre possibilité de boucle est la condition while. Sa syntaxe générale est la
suivante :

> while (condition){

+ expr1
+ expr2
+ ...
+ }
Les ordres expr1, expr2, etc. sont eectués tant que la condition est vraie, celle-ci
étant évaluée en début de boucle. Dès que la condition est fausse, la boucle est
arrêtée.
Ainsi,

> i <- 1
> while (i<3){
+ print(i)
+ i<-i+1
+ }
permet d'acher i et de l'augmenter de 1 tant que i est inférieur à 3.
Une dernière possibilité de boucle est l'ordre repeat. Il se comprend comme répéter
indéniment des ordres. La sortie de boucle est assurée par l'ordre break. Cet ordre
peut être utilisé quelle que soit la boucle. Un exemple est donné dans le paragraphe
suivant.

Les conditions (if, else)

Il s'agit d'exécuter un ordre sous condition : l'ordre est exécuté si et seulement
si la condition est vraie. Si la condition n'est pas vraie, alors l'ordre après else est
exécuté. Dans sa forme générale, il s'écrit :

> if (condition){
+ expr1
+ expr2
+ ...
+ } else{
+ expr3
+ expr4
+ ...
+ }

29
Attention, l'ordre else doit être sur la même ligne que la parenthèse fermante "}" de
la clause if.
Si nous souhaitons utiliser la boucle repeat pour imprimer i variant de 1 à 3 compris,
nous devons sortir de la boucle, avant l'impression, quand i est supérieur à 3 :

> i<-1
> repeat{
+ print(i)
+ i <- i+1
+ if(i>3) break}
Ici, si i est supérieur à 3, nous n'avons à eectuer qu'un ordre break (break), il n'est
donc pas utile de grouper les commandes.

Vectorisation
Les boucles et structures de contrôle peuvent cependant être évitées dans la
plupart des situations et ce grâce à la vectorisation. La structure vectorielle rend les
boucles implicites dans les expressions. Considérons l'addition de deux vecteurs :

> z <- x + y
Cette addition pourrait être écrite avec une boucle comme cela se fait dans la plupart
de langages :

> z <- numeric(length(x))

> for (i in 1:length(z)) z[i] <- x[i] + y[i]
Dans ce cas il est nécessaire de créer le vecteur z au préalable à cause de l'utilisation
de l'indexation. On réalise que cette boucle explicite ne fonctionnera que si x et y
sont de même longueur : elle devra être modiée si cela n'est pas le cas, alors que la
première expression marchera quelque soit la situation.
Les expressions vectorisées sont non seulement plus simples, mais aussi plus e-
caces d'un point de vue informatique, particulièrement pour les grosses quantités de
données.
Il y a également les fonctions du type "apply" qui évitent d'écrire des boucles.

1.7 Les graphiques

1.7.1 Les fonctions graphiques

Nous présentons de manière succincte, quelques principaux types de graphiques
basiques pour une seule variable (x), deux variables (x et y ) et la représentation des
courbes.

30
Table 1.7  Principaux types de graphiques basiques pour une seule variable x.
Type de graphique Exemple d'appel de fonction Type de x
diagramme en secteurs (pie chart) pie(table(x), ...) facteur
diagramme à barres (bar plot) barplot(table(x), ...) facteur

histogramme hist(x, ...) vecteur numérique

diagramme en boîte (boxplot) boxplot(x, ...) vecteur numérique

diagramme quantile-quantile
qqnorm(x, ...) vecteur numérique
théorique normal

Exemple 1
On s'intéresse à la variable 'état-civil' notée X et à la série statistique des valeurs
prises par X sur 20 personnes.
On a M M D C C M C C C M C M V M V D C C C M, où C : célibataire, M :
marié(e), V : veuf(ve) et D : divorcée.

> X=c("Marie(e)","Marie(e)","Divorce(e)","Celibataire","Celibataire",
+ "Marie(e)","Celibataire", "Celibataire","Celibataire","Marie(e)",
+ "Celibataire","Marie(e)","Veuf(ve)","Marie(e)", "Veuf(ve)",
+ "Divorce(e)","Celibataire","Celibataire","Celibataire","Marie(e)")
> T1=table(X); T1

X
Celibataire Divorce(e) Marie(e) Veuf(ve)
9 2 7 2

> pie(T1) # diagramme en camembert

31
 Celibataire

Divorce(e)

Veuf(ve)

Marie(e)

> T1

X
Celibataire Divorce(e) Marie(e) Veuf(ve)
9 2 7 2

> barplot(T1) # diagramme en barre

32
 8
6
4
2
0

Celibataire Divorce(e) Marie(e) Veuf(ve)

Exemple 2
Un quartier est composé de 50 ménages, et la variable Y représente le nombre
de personnes par ménage.
11111222222222333333333333333444444444455555566688

> Y=c(1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
+ 4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,6,6,6,8,8)
> T2=table(Y); T2

Y
1 2 3 4 5 6 8
5 9 15 10 6 3 2

> plot(T2,type="h",xlab="",ylab="",main="",frame=0,lwd=3)

33
 15
10
5
0

1 2 3 4 5 6 8

Exemple 3
On mesure la taille en centimètres de 50 élèves d'une classe.
152 152 152 153 153 154 154 154 155 155 156 156 156 156 156 157 157 157 158 158
159 159 160 160 160 161 160 160 161 162 162 162 163 164 164 164 164 165 166 167
168 168 168 169 169 170 171 171 171 171.

> S=c(152,152,152,153,153,154,154,154,155,155,156,156,156,156,156,157,
+ 157,157,158,158,159,159,160,160,160,161,160,160,161,162,162,162,163,
+ 164,164,164,164,165,166,167,168,168,168,169,169, 170,171,171,171,171)
> T3=table(cut(S, breaks=c(151,155,159,163,167,171))); T3

(151,155] (155,159] (159,163] (163,167] (167,171]

10 12 11 7 10

> hist(S,breaks=c(151.5,155.5,159.5,163.5,167.5,171.5), freq=FALSE,

+ xlab="",ylab="",main="",xaxt = "n")
> axis(1, c(151.5,155.5,159.5,163.5,167.5,171.5))

34
 0.06
0.05
0.04
0.03
0.02
0.01
0.00

151.5 155.5 159.5 163.5 167.5 171.5

> boxplot(S)

35
 170
165
160
155

> qqnorm(S)

36
 170
165
Normal Q−Q Plot
Sample Quantiles

160
155

−2 −1 0 1 2

Theoretical Quantiles

Représentation de deux variables quantitatives

Lorsque les observations de deux variables sont stockées dans deux vecteurs nu-
mériques x et y , on peut utiliser le diagramme de dispersion (scatterplot) pour la
représentation graphique.
On mesure le poids Y et la taille X de 20 individus.

Table 1.8  Poids Y et la taille X de 20 individus.

yi xi yi xi
60 155 75 180
61 162 76 175
64 157 78 173
67 170 80 175
68 164 85 179
69 162 90 175
70 169 96 180
70 170 96 185
72 178 98 189
73 173 101 187

> poids=c(60,61,64,67,68,69,70,70,72,73,75,76,78,80,85,90,96,96,98,101)

37
> taille=c(155,162,157,170,164,162,169,170,178,173,180,175,173,175,179,
+ 175,180,185,189,187)
> plot(taille,poids)
100
90
poids

80
70
60

155 160 165 170 175 180 185 190

taille

Représentation graphique d'une expression mathématique

La fonction curve permet de tracer une courbe dans un repère cartésien, sur un
intervalle dont les bornes sont spéciées par les arguments from et to. La syntaxe
de la fonction est : curve(expr, from, to, ...).

> curve(expr = x^2 -4*x +3, from = 0, to = 5,

+ main = "Fonction polynomiale de degré deux",
+ ylab = expression(paste(x^2, "-4*x +3")))

38
 8
6
Fonction polynomiale de degré deux
x2−4*x +3

4
2
0

0 1 2 3 4 5

Le code suivant produit le même graphique, mais l'utilisation de la fonction curve

crée une commande plus succincte.

> x <- seq(from = 0, to = 5, length = 101)

> plot(x = x, y = x^2 -4*x +3, type = "l",
+ main = "Fonction polynomiale de degré deux",
+ ylab = expression(paste(x^2, "-4*x +3")))
L'argument add=TRUE permet d'indiquer à R de superposer la courbe désirée
à un graphique préexistant.

> curve(expr = x^2 -4*x +3, from = 2, to = 5)

39
 8
6
x^2 − 4 * x + 3

4
2
0

2.0 2.5 3.0 3.5 4.0 4.5 5.0

> f = function(x) { x^2 -4*x +3 }

> g = function(x) { x^2 -6*x +8 }
> curve(f(x), 0, 5, col = "red", xlab = "x", ylab = "y", lwd = 2,
+ main = "Graphiques de f(x) et g(x)")
> curve(g(x), col = "blue", lwd = 2, add = TRUE)
> grid()
> legend("topleft", col = c("red", "blue"), lty=1, legend = c("f(x)", "g(x)"))

40
 8
Graphiques de f(x) et g(x)

f(x)
g(x)
6
4
y

2
0

0 1 2 3 4 5

1.7.2 Gestion de la fenêtre graphique

Les paramètres des fenêtres graphiques sont gérés dans R via la fonction par.
par(new=TRUE) : les prochains tracés se superposeront aux tracés déjà eectués
dev.o() : fermeture de la fenêtre graphique active
par(mfrow=c(n,m)) : partage la fenêtre graphique active en une fenêtre de n lignes
et m colonnes.
pdf("le.txt") : écrit les commandes graphiques qui suivent dans un chier pdf, ne
pas oublier de terminer ces instruction par dev.o().

1.7.3 Ajout des éléments au graphique

La fonction text()
Cette fonction permet d'ajouter du texte sur un graphique. Elle permet aussi,
ce qui est très intéressant, d'y ajouter des formules mathématiques. Il faut donner
les coordonnées en x et en y du centre de la chaîne de caractères à acher, et bien
entendu la chaîne elle-même. Si l'on veut écrire une expression mathématique, il faut
utiliser la fonction expression(). La fonction bquote() peut aussi être utile.

> plot(1:10,1:10,xlab=bquote(x[i]),ylab=bquote(y[i]))
> text(3,6,"du texte")

41
> text(4,9,expression(widehat(B) == (X^T * X)^{-1} * X^T * y))
10

B = (XTX)−1XTy
8

du texte
6
yi

4
2

2 4 6 8 10

xi

La fonction legend()
Cette fonction est utilisée pour ajouter une légende à un graphique existant.

Table 1.9  Description des arguments de la légende.

Argument Description
x, y Spécient les coordonnées de l'emplacement de la lé-
gende sur un graphique
legend Vecteur de chaînes de caractères ou d'expressions devant
apparaître dans la légende.
ll Vecteur de couleurs devant apparaître à côté du texte
dans la boîte de légende.
lty,lwd Entier ; le type des lignes ou l'épaisseur des traits qui
apparaissent dans la légende.
col Vecteur de couleurs des points ou des lignes apparaissant
dans la légende.

> plot(1:4,1:4,col=1:4)
> legend(x=3,y=2.5,legend=c("a","b","c","d"),fill=1:4)

42
 Voici deux tableaux résumant quelques arguments et paramètres graphiques les
plus communs :

Table 1.10  Arguments et paramètres graphiques les plus communs.

Arguments Éléments graphiques contrôlés
main spécie le titre principal
xlab, ylab titre de l'axe des x et des y
xlim, ylim Vecteur de longueur 2 qui spécie l'intervalle de valeurs
à utiliser pour l'axe des x et des y.
type spécie le type de graphique à tracer ("p" = points,
"l" = lignes, "b" = les deux, , "c" lignes coupées au
niveau des points, "o" lignes et points superposés, "h"
lignes verticales, "s" marches d'escalier (step) et "n" rien
tracer (mais ache la fenêtre de tracé avec les axes))
bty si "n", retire le cadre autour de la zone graphique
lwd épaisseur des lignes
lty type des lignes
pch symbole pour les points
orientation des étiquettes des axes
las (0 = parallèle à l'axe, 1 = horizontale,
2 = perpendiculaire à l'axe, 3 = verticale)
cex taille des caractères dans la zone graphique
cex.main, cex.sub taille des caractères dans le titre principal, dans les sous-
titres
cex.axis, cex.lab taille des caractères dans les étiquettes des axes, dans
les noms des axes
col couleur du graphique
col.main, col.sub couleur pour le titre principal, et des sous-titres
col.axis, col.lab couleur pour les étiquettes des axes, noms des axes
par(mfrow = c( , )) division de la fenêtre graphique

1.8 Racines, dérivation et intégration de fonctions

1.8.1 Racines
Les racines d'une fonction f sont dénies comme étant les solutions de l'équation
f (x) = 0.

Cas d'une racine unique

Dans le cas d'une racine unique, on utilise la fonction uniroot() eectuant une
recherche unidimensionnelle sur un intervalle donné. Voilà par exemple comment on
peut déterminer la valeur qui annule la fonction cos(x2 ) sur l'intervalle [0, 2]. La

43
solution analytique à ce simple problème est :

> uniroot(f=function(x){cos(x^2)},lower=0,upper=2)$root
[1] 1.253319
> uniroot(f=function(x){x-2},lower=0,upper=3)$root
[1] 2

Cas des racines d'un polynôme

La fonction polyroot() sert à trouver toutes les racines d'un polynôme (possible-
ment complexes). Par exemple, trouvons les racines des polynômes P (x) = 3−4x+x2
et P (x) = 8 − 6x + x2
> polyroot(c(3,-4,1))
[1] 1+0i 3+0i
> polyroot(c(8,-6,1))
[1] 2+0i 4-0i

1.8.2 Dérivée
La dérivée des expressions simples s'obtient à partir de la fonction D.

> D(expression(x^2),"x") # Dérivée de x^2 par rapport à x

2 * x
> D(expression(x+(x^2)+(2*z^3)), "z") # Dérivée par rapport à z
2 * (3 * z^2)

1.8.3 Intégration
Le calcul intégral s'eectue à partir de la fonction integrate.

> f = function(x) { x^2 -4*x +3 }

> g = function(x) { 3*x^2 +2 }
> integrate(f, 0, 1)
1.333333 with absolute error < 1.5e-14
> integrate(g, -1, 1)
6 with absolute error < 6.7e-14

44
Bibliographie

[1] Pierre-André Cornillon, Arnaud Guyader, François Husson, Nicolas Jégou, Jolie
Josse, Maela Kloareg, Eric Matzner-Lober, Laurent Rouvière, Statistiques avec
R, 3è édition revue et augmentée, Pratique de la Statistique, Presses universi-
taires de Rennes, 2012, 296p.
[2] Emmanuel Paradis, R pour les débutants, 2005, 81p.
[3] Vincent Goulet, Introduction à la programmation en R, 5è édition, Bibliothèque
et Archives Canada, 2016, 218p.
[4] Frédéric Bertrand, Myriam Maumy-Bertrand, Initiation à la statistique avec
R : Cours, exemples, exercices et problèmes corrigés, 2è édition ; DUNOD, 2014,
417p.
[5] Christophe Genolini, Lire ; Compter ; Tester... avec R Préparation des données
/ Analyse univariée / Analyse bivariée, 31p.
[6] Yves Tillé, Résumé du cours de statistique descriptive, 2010, 172p.
[7] Sophie Baillargeon, Graphiques en R (notes de cours) ;
https ://stt4230.rbind.io/communication_resultats/graphiques_r/
[8] Christophe Chesneau. Introduction aux graphiques avec R. Licence. France.
2016. cel-01389940f
[9] https ://membres-ljk.imag.fr/Bernard.Ycart/mel/dr/node7.html

45