Langage R

Nicolas Baradel
[Link]@[Link]
 Plan
1

Introduction
Premiers pas
Les conditionnelles
Les boucles
Les fonctions
Les variables
Les objets
Fonctions usuelles
Programmation efficace
Simulation de variables aléatoires

Nicolas Baradel | Langage R

 Introduction
R en quelques mots
2

I R est un langage interprété ;

I R se programme de manière vectorielle ;
I R orienté pour les applications en statistiques et en
probabilités.

Nicolas Baradel | Langage R

 Introduction
Où trouver R 3

I R se télécharge à [Link] ;
I La version 64-bit ne fonctionne que sur les systèmes 64-bit, la
version 32-bit fonctionne sur les deux systèmes ;
I Dans la version 32-bit, R ne peut allouer qu’environ 3 Go de
mémoire vive ;
I Tous les systèmes d’exploitations modernes sont en 64-bit :
téléchargez la version 64-bit.

Nicolas Baradel | Langage R

 Introduction
Comment utiliser R 4

I R dispose de Rgui qui est une console R légèrement plus

avancée ;
I Rgui dispose d’un système de gestion de scripts R ;
I Rgui est minimal, notamment la version Windows ;
I Il existe RCode : un système moderne de gestion de projets R ;
I RCode se télécharge à [Link]

Nicolas Baradel | Langage R

 Introduction
Comment utiliser R 5

Nicolas Baradel | Langage R

 Introduction
Comment utiliser R 6

I Il existe RCode : un système moderne de gestion de projets R ;

I RCode se télécharge à [Link]

Nicolas Baradel | Langage R

 Introduction
Comment utiliser R 7

Nicolas Baradel | Langage R

 Introduction
Comment utiliser R 8

RCode se décompose en les vues :

I : un dossier contenant votre projet ;
I : pour éditer le code ;
I : pour interagir avec R ;
I : pour charger et installer des packages ;
I : utilisé pour l’aide de R et afficher les sorties HTML ;
I : affiche l’historique des commandes envoyées à R ;
I : affiche en temps réel les variables instanciées dans
R et permet leur visualisation / édition.

Nicolas Baradel | Langage R

 Premiers pas
Opérations élémentaires
9

I 1
[1] 1
I "R"
[1] "R"
I 5+7
[1] 12
I 1+(1+1/2*(1+1/3*(1+1/4*(1+1/5))))
[1] 2.716667
I TRUE
[1] TRUE

Nicolas Baradel | Langage R

 Premiers pas
Affectation 10

I R a un typage faible ;
I On ne précise pas le type, mais toutes les variables ont un type
implicite ;
I L’affectation se fait avec = ou <-
I x = 3
x
[1] 3
I y <- 4
y
[1] 4
I (z <- xy)
[1] 81
I On préféra <- qui est l’opérateur d’affectation standard de R.

Nicolas Baradel | Langage R

 Premiers pas
Type des variables
11

I La fonction typeof permet d’obtenir le type d’une variable sous

la forme d’une chaîne de caractères.
I x <- "R"
typeof(x)
[1] "character"
I typeof(TRUE)
[1] "logical"
I typeof(pi)
[1] "double"
I typeof(5)
[1] "double"

Nicolas Baradel | Langage R

 Les conditionnelles
Booléens 12

I Les booléens sont les variables de type logical ;

I Il y a TRUE et FALSE ;
I L’opérateur && correspond au ET logique ;
I TRUE && FALSE
[1] FALSE
I L’opérateur || correspond au OU logique ;
I TRUE || FALSE
[1] TRUE
I L’opérateur ! correspond au NON logique ;
I !TRUE
[1] FALSE

Nicolas Baradel | Langage R

 Les conditionnelles
If 13

I Une condition se fait avec if de la manière suivante :

if(condition)
{
instructions
}
I condition est un booléen qui vaut TRUE ou FALSE ;
I Le bloc instructions est exécuté si et seulement si condition
vaut TRUE ;

Nicolas Baradel | Langage R

 Les conditionnelles
If 14

I x <- 7 #Ceci est un commentaire

if(x %% 2 == 1) #Si x modulo 2 est égal à 1
{
cat("x est impair\n") #cat permet d'écrire dans la
console, \n permet de faire un retour à la ligne
}
x est impair
I Il est possible d’ajouter des instructions si la condition n’est pas
réalisée avec le mot-clé else.
I Toutefois, si on ajoute else ici à la suite, on obtiendra une erreur
car R aura déjà exécuté le if et aura terminé cette instruction.
I Soit on encadre la condition par des accolades, soit on écrit le
mot-clé else sur la même ligne que l’accolade fermante du if.

Nicolas Baradel | Langage R

 Les conditionnelles
else 15

I x <- x + 1 #x <- 8
if(x %% 2 == 1) #FALSE
{
cat("x est impair\n")
} else
{
cat("x est pair\n")
}
x est pair

Nicolas Baradel | Langage R

 Les boucles
for 16

I Une boucle for est une instruction qui est réalisée sur un
ensemble i ∈ I. Le plus courant est d’effectuer une instruction
sur i ∈ {1, 2, . . . , n} pour n ∈ N∗ . À cette fin, l’opérateur :
complète par les entiers entre le membre de gauche et le
membre de droite :
I 1:5
[1] 1 2 3 4 5
I Il s’agit d’un vecteur que nous verrons plus loin, ici I est
{1, 2, . . . , 5} représenté par 1:5. La boucle for a la sémantique :
I for(i in I)
{
instructions
}

Nicolas Baradel | Langage R

 Les boucles
for 17

I I <- 1:5
I for(i in I)
{
cat(paste0("Itération i = ", i, "\n")) #paste0
permet de concaténer des chaînes de charactères
}
Itération i = 1
Itération i = 2
Itération i = 3
Itération i = 4
Itération i = 5

Nicolas Baradel | Langage R

 Les boucles
while 18

I La boucle while permet de répéter une instruction tant qu’une

condition est vérifiée. Sa syntaxe est :
I while(condition)
{
instructions
}
I Une boucle for peut toujours s’écrire comme une boucle while :
I i <- 1
while(i <= n)
{
instructions
i <- i+1
}
I Attention aux boucles infinies avec while.

Nicolas Baradel | Langage R

 Les boucles
while 19

I n <- 123456789
I i <- 2
{
while(n != 1) #Tant que n est différent de 1
{
if(n %% i == 0)
{
cat(paste0(i, " "))
n <- n %/% i #Division euclidienne (entière)
}
else
i <- i+1
}
cat("\n")
}
3 3 3607 3803
Nicolas Baradel | Langage R
 Les fonctions
20

I Une fonction prend une ou plusieurs valeurs et retourne une

variable ;
I Une fonction peut ne rien retourner, elle peut aussi ne pas
prendre d’argument.
I nomfonction <- function(arg1, ..., argn)
{
instructions
}
I L’appel se fait :
I nomfonction(x1, ..., xn)
I Si la fonction renvoie une valeur, elle se termine par return ; dès
qu’un return est rencontré, l’execution de la fonction s’arrête.
I Par exemple, return("R") permet de retourner la chaîne de
caractère "R".

Nicolas Baradel | Langage R

 Les fonctions
21

I R contient beaucoup de fonctions ;

I sqrt(2) #fonction racine carrée
[1] 1.414214
I sum(1:100) #sum prend un vecteur en argument (que nous
verrons au chapitre suivant) et renvoie la somme des
éléments
[1] 5050
I Mettons le code qui décomposait en nombres premiers en
fonction.

Nicolas Baradel | Langage R

 Les fonctions
22

I premiers <- function(n)

{
i <- 2
while(n != 1)
{
if(n %% i == 0)
{
cat(paste0(i, " "))
n <- n %/% i
}
else
i <- i+1
}
cat("\n")
}
I premiers(123456789)
3 3 3607 3803
Nicolas Baradel | Langage R
 Exercices
Énoncés 23

I Écrire une fonction factorielle qui calcule le nombre factoriel

d’un entier naturel ; la fonction de R qui fait ça est factorial ;
I Écrire une fonction gammaEuler qui approxime à l’ordre n ∈ N∗ la
constante γ d’Euler définie par la limite :
n
!
X 1
γ = lim − log(n) .
n→+∞ k
k =1

On pourra vérifier avec -digamma(1) qui vaut γ.

Nicolas Baradel | Langage R

 Exercices
Énoncés 24

I Écrire une fonction qui calcule le n-ème élément de la suite de

Fibonacci de valeur initiale u0 et u1 en mettant les valeurs par
défaut :u0 = 0, u1 = 1. La suite de Fibonacci est définie par :

U0 = u0 ,
U1 = u1 ,
Un+2 = Un+1 + Un , n ≥ 0.

Nicolas Baradel | Langage R

 Exercices
Corrections 25

I facto <- function(n)

{
if(n == 0)
return(1)

fac <- 1
for(i in 1:n)
fac <- fac * i
return(fac)
}

Nicolas Baradel | Langage R

 Exercices
Corrections 26

I gammaEuler <- function(n)

{
gamma <- - log(n)
for(k in 1:n)
gamma <- gamma + 1/k
return(gamma)
}

Nicolas Baradel | Langage R

 Exercices
Corrections 27

I fibonacci <- function(n, u0=0, u1=1)

{
if(n == 0)
return(u0)
if(n == 1)
return(u1)
u <- 0
um1 <- u1
um2 <- u0
for(i in 1:n)
{
u <- um1 + um2
um2 <- um1
um1 <- u
}
return(u)
}
Nicolas Baradel | Langage R
 Les variables
Les types - numériques
28

I Le type d’une variable se récupère avec la fonction typeof.

I typeof(2)
[1] "double"
I Le type par défaut des variables numériques est le double.
I L’entier existe, il suffit de mettre le caractère L à la fin du nombre.
I (x <- 1L)
[1] 1
I typeof(x)
[1] "integer"
I De manière générale, ces deux types sont numeric et la fonction
[Link] renvoie TRUE pour ceux deux types.
I Il est possible de faire un programme R entier sans se soucier de
cela, si besoin, R fera automatiquement les conversions.
I [Link](1) && [Link](1L)
[1] TRUE
Nicolas Baradel | Langage R
 Les variables
Les types - booléens
29

I Le type booléen contient deux alternatives : TRUE et FALSE.

I Il est nommé logical dans R.
I Il existe aussi la valeur NA qui représente une information
indisponible.

Nicolas Baradel | Langage R

 Les variables
Les types - chaîne de caractères
30

I Le type character représente les chaînes de caractères.

I L’affectation se fait de la manère suivante :
I s <- "rpgm"
I Pour concaténer une chaîne de caractère, nous utilisons la
fonction paste0 et pour afficher une chaîne de caractère, la
fonction cat.
I cat(paste0(s, "\n"))
rpgm
I La fonction substr permet d’extraire une sous-chaîne de
caractères en indiquant le premier et le dernier caractère.
I substr(s, 2, 4)
[1] "pgm"

Nicolas Baradel | Langage R

 Les variables
Les types - chaîne de caractères
31

I Les fonctions tolower et toupper permettent de mettre

respectivement en minuscule et en majuscule une chaîne de
caractères.
I toupper(s)
[1] "RPGM"
I Il existe bien d’autres fonctions de manipulation des chaînes de
caractères.

Nicolas Baradel | Langage R

 Les variables
Les types - dates
32

I Le type Date est un type bien utile pour manipuler des données
dont l’une des variable est une date précise.
I Pour créer une date depuis une châine de caractère, on utile la
fonction [Link] de la manière suivante :
I (R <- [Link]("29/02/2000", "%d/%m/%Y"))
[1] "2000-02-29"
I Dans la chaîne de caractères, %d indique la position du jour, %m
celle du mois et %Y celle de l’année.
I La fonction format convertit une date en chaîne de caractères.
I format(R, "%d/%m/%Y")
[1] "29/02/2000"
I La date du jour est donnée par :
I [Link]()
[1] "2018-06-12"

Nicolas Baradel | Langage R

 Les objets
vecteur 33

I Le vecteur est l’objet fondamental de R.

I Il s’agit d’un regroupement de valeurs de même type.
I Pour créer un vecteur de type double et de taille 3, on écrit :
I (x <- numeric(3))
I [1] 0 0 0
I On peut accéder à un élément en utilisant [] :
I x[1]
[1] 0
I L’indexation démarre à 1 et se fait de 1 à n.

Nicolas Baradel | Langage R

 Les objets
vecteur 34

I Un vecteur que nous avons déjà croisé :

I 1:5
[1] 1 2 3 4 5
I La fonction length permet de renvoyer la longueur d’un vecteur.
I length(x)
[1] 3
I Il est possible de concaténer des éléments pour former un
vecteur
I (x <- c(1, 3, 7))
[1] 1 3 7
I Et même de concaténer des vecteurs
I c(x, x)
[1] 1 3 7 1 3 7

Nicolas Baradel | Langage R

 Les objets
vecteur 35

I En fait, une variable de taille 1 est représentée comme un

vecteur dans R.
I x <- pi
I x[1]
[1] 3.141593
I length(x)
[1] 1
I La fonction rep permet de créer un vecteur de taille n dont
chaque composante est identique.
I rep(5, 3)
[1] 5 5 5

Nicolas Baradel | Langage R

 Les objets
vecteur 36

I La fonction seq (pour sequence) permet de créer une suite de

nombre régulière.
I seq(1, 2, 0.2)
[1] 1.0 1.2 1.4 1.6 1.8 2.0
I seq(0, 1, length=6)
[1] 0.0 0.2 0.4 0.6 0.8 1.0

Nicolas Baradel | Langage R

 Les objets
vecteur 37

I Il est possible de donner un vecteur de booléens qui donne les

indices à garder.
I x <- c(1, 3, 5)
x[c(FALSE, TRUE, TRUE)]
[1] 3 5
I Il est possible de donner directement la valeur des indices
choisis.
I x[c(1, 3, 3, 2)]
[1] 1 5 5 3
I Une autre possibilité est d’appeler tous les éléments sauf un. La
syntaxe est x[-a] où a est un indice entier.
I x[-2]
[1] 1 5

Nicolas Baradel | Langage R

 Les objets
vecteur 38

La règle suivante est fondamentale sur R.

I Tous les opérateurs (arithmétiques, logiques, etc.) appliqués à
deux vecteurs de même taille renvoient un vecteur de même
taille où l’opérateur a été appliqué élément par élément.
I y <- 0:2
x+y
[1] 1 4 7
x*y
[1] 0 3 10
xy
[1] 1 3 25
x == y
[1] FALSE FALSE FALSE

Nicolas Baradel | Langage R

 Les objets
vecteur 39

Autre règle fondamentale : le recyclage.

I Tous les opérateurs définis précédemment (arithmétiques,
logiques, etc.) appliqués à un vecteur et une variable de taille un
renvoient un vecteur où l’opérateur a été appliqué à la variable et
à tous les éléments du vecteur initial un à un.
I 2*x+1
[1] 3 7 11
x2
[1] 1 9 25
factorial(x) %% 2
[1] 1 0 0
x <= 2
[1] TRUE FALSE FALSE

Nicolas Baradel | Langage R

 Les objets
Exercices 40

I Ecrire une fonction f qui prend n en argument et qui renvoie un

vecteur composé des n + 1 premiers carrés de N.
I Ajoutez un test qui permet de s’assurer que n est un nombre
positif (s’il n’est pas entier, on pourra arrondir à l’inférieur). Pour
cela, on pourra utiliser la fonction stop qui permet d’arrêter le
programme en générant un message d’erreur (en argument) et
[Link] qui renvoie un type entier d’un nombre numérique,
arrondi à l’inférieur s’il n’était pas entier.

Nicolas Baradel | Langage R

 Les objets
Exercices 41

I Ecrire une fonction deriv1 qui prend un vecteur x, un pas h, et

qui renvoie un vecteur de taille length(x) - 1 l’approximation
du nombre dérivé :
xi+1 − xi
∂[h] xi := .
h
On fera sans boucle.

Nicolas Baradel | Langage R

 Les objets
Correction 42

I f <- function(n) ##cas simple: return((0:n)2)

{
if([Link](n))
{
if(n >= 0)
return( (0:[Link](n))2 )
stop(paste0("Le nombre ", n, " est négatif"))
}
stop(paste0("La valeur ", n, " n'est pas
numérique"))
}

Nicolas Baradel | Langage R

 Les objets
Correction 43

I deriv1 <- function(x, h)

return((x[-1] - x[-length(x)])/h)

Nicolas Baradel | Langage R

 Les objets
matrice 44

I Une matrice est un vecteur avec une représentation à deux

indices.
I Une matrice se crée avec la fonction matrix dans laquelle on
donne un vecteur, le nombre de lignes, le nombre de colonnes.
I (X <- matrix(1:9, 3, 3))
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
I On peut accéder à un élément (i, j) en utilisant [, ] :
I X[2, 3]
[1] 8

Nicolas Baradel | Langage R

 Les objets
matrice 45

I On peut aussi l’appeler en utilisant un indice de type vecteur, i.e.

on utilisant :
i 0 := j + (i − 1) ∗ nrow
I X[8]
[1] 8
I Il est possible de remplir une matrice par ligne avec l’argument
byrow = TRUE.
I La fonction [Link] permet de convertir un vecteur de taille n
en une matrice à n lignes et une colonne.
I La fonction t permet d’obtenir la matrice tranposée.
I Le produit matriciel se fait avec %*% et non pas avec *, ce
dernier est le produit des deux matrices élément par élément

Nicolas Baradel | Langage R

 Les objets
matrice 46

I Il est possible de construire une matrice diagonale avec diag :

I diag(1:3)
[,1] [,2] [,3]
[1,] 1 0 0
[2,] 0 2 0
[3,] 0 0 3
I La fonction cbind permet de combiner des vecteurs en une
matrice en les plaçant par colonne :
I cbind(rep(1,3), rep(2,3), rep(3,3))
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 1 2 3
[3,] 1 2 3

Nicolas Baradel | Langage R

 Les objets
matrice 47

I La fonction rbind fait la même chose mais en plaçant les

vecteurs en ligne
I Il est possible de nommer les lignes et les colonnes en utilisant
l’argument dimnames :
I X <- matrix(1:9, 3, 3, dimnames = list(c("R1", "R2",
"R3"), c("C1", "C2", "C3")))
I X
C1 C2 C3
R1 1 4 7
R2 2 5 8
R3 3 6 9

Nicolas Baradel | Langage R

 Les objets
matrice 48

I On peut extraire une ligne ou une colonne sous la forme d’un

vecteur en ne spécifiant que l’indice la ligne ou de la colonne
I X[1, ]
C1 C2 C3
1 4 7
I X[, 1]
R1 R2 R3
1 2 3
I On peut aussi utiliser le nom de la ligne ou de la colonne
I X["R1", ]
C1 C2 C3
1 4 7

Nicolas Baradel | Langage R

 Les objets
matrice 49

I Il est possible de forcer la conservation du type matrix avec

l’argument drop = FALSE
I c([Link](X[1, ]), [Link](X[1, ,drop=FALSE]))
[1] FALSE TRUE
I dim(X[1, ,drop=FALSE]) #dim renvoie le nombre de
lignes et de colonnes
[1] 1 3
I La fonction length renverra le nombre total d’éléments de la
matrice
I length(X)
[1] 9
I On peut obtenir le nombre de lignes grâce à la fonction nrow et le
nombre de colonnes grâce à la fonction ncol
I c(nrow(X), ncol(X))
[1] 3 3
Nicolas Baradel | Langage R
 Les objets
[Link] 50

I Le type [Link] est le type naturelle des matrices de

données
I La matrice a un type unique pour l’ensemble de ses éléments
I La [Link] a un type unique par colonne où chaque colonne
représente une caractéristique et chaque ligne une donnée
I Exemple de [Link] :
I (X <- [Link](Prenom = c("Joseph", "Augustin"), age
= c(15, 19)))
Prenom age
1 Joseph 15
2 Augustin 19

Nicolas Baradel | Langage R

 Les objets
[Link] 51

I Les appels peuvent se faire comme ceux d’une matrice

I X[, "Prenom"]
[1] Joseph Augustin
Levels: Augustin Joseph
I X$age
[1] 15 19
I On remarque que la première ne semble pas représenter une
chaîne de caractères. La fonction str permet de voir le type par
colonne.
I str(X)
'[Link]': 2 obs. of 2 variables:
$ Prenom: Factor w/ 2 levels "Augustin","Joseph": 2 1
$ age : num 15 19

Nicolas Baradel | Langage R

 Les objets
[Link] 52

I Par défaut, dans R 3.y.z et antérieurs les chaînes de caractères

sont considérées comme des factor qui représentent des
modalités, pour les régressions.
I Il est possible de forcer à conserver les chaînes de caractères
avec stringsAsFactors = FALSE
I (X <- [Link](Prenom = c("Joseph", "Augustin"), age
= c(15, 19)), stringsAsFactors = FALSE)
Prenom age
1 Joseph 15
2 Augustin 19

Nicolas Baradel | Langage R

 Les objets
[Link] 53

I Mais cette fois, le type est bien character

I str(X)
'[Link]': 2 obs. of 2 variables:
$ Prenom: chr "Joseph" "Augustin"
$ age : num 15 19
I Depuis R 4.0.0 (avril 2020), les chaînes de caractères sont bien
importées en chaîne de caractères.

Nicolas Baradel | Langage R

 Les objets
Liste 54

I La liste est un regroupement d’objets arbitraires

I L’exemple suivant illustre la création d’une liste
I (l0 <- list(a = TRUE, b = 1:3))
$a
[1] TRUE
$b
[1] 1 2 3
I L’appel peut se faire par le nom avec $ ou [[]]
I l0$a
[1] TRUE
I l0[["a"]]
[1] TRUE

Nicolas Baradel | Langage R

 Les objets
Liste 55

I L’appel peut aussi se faire via l’indice numérique

I l0[[1]]
[1] TRUE
I L’ajout de nouveaux éléments à la liste se fait facilement :
I l0$c <- "s"
I l0$c
[1] "s"

Nicolas Baradel | Langage R

 Les objets
Exercices 56

I Si la fonction dim de R est appliquée à un vecteur, elle renvoie

NULL. Si elle est appliquée à une matrice de taille n × m, elle
renvoie n et m. Écrire une fonction DIM qui renvoie la taille du
vecteur entré en argument (si l’argument est un vecteur) et la
valeur habituelle de dim sinon.
I Écrire une fonction qui teste le type de l’argument. Si celui-ci est
un vecteur, la fonction renvoie le dernier élément. Si celui-ci est
une matrice, la fonction renvoie le dernier élément de la première
ligne.

Nicolas Baradel | Langage R

 Fonctions usuelles
57

I sign : fonction signe, renvoie 1 si l’argument est positif, 0 s’il est

nul, -1 s’il est négatif ;
I abs : fonction valeur absolue ;
I sqrt : fonction racine carrée ;
I exp : fonction exponentielle ;
I log : fonction logarithme, le second argument (base) est la base
du logarithme ;
I log2, log10 : logarithme de base 2 et 10 ;
I expm1 : fonction x 7→ exp(x) − 1 ;
I log1p : fonction x 7→ log(1 + x) ;

Nicolas Baradel | Langage R

 Fonctions usuelles
58

I cos : fonction cosinus ;

I sin : fonction sinus ;
I tan : fonction tangente ;
I acos : fonction arccosinus ;
I asin : fonction arcsinus ;
I atan : fonction arctangente ;
I cosh : fonction cosinus hyperbolique, x 7→ ex +e−x
2 ;
I sinh : fonction ex −e−x
sinus hyperbolique, x 7→ 2 ;
I tanh : fonction sinh(x)
tangente hyperbolique, x 7→ cosh(x) ;

Nicolas Baradel | Langage R

 Fonctions usuelles
59

I sort : trie un vecteur ;

I order : renvoie les indices d’un vecteur de tel sorte que
x[order(x)] renvoie sort(x) ;
I [Link] : renvoie l’indice du minimum d’un vecteur ;
I [Link] : renvoie l’indice du maximum d’un vecteur ;
I sum : renvoie la somme d’un vecteur ;
I mean : renvoie la moyenne d’un vecteur ;
I var : renvoie la variance d’un vecteur ;

Nicolas Baradel | Langage R

 Exercices
Énoncés 60

I Soit X une variable aléatoire dont la densité est définie par la

fonction f :
tan2 (x)
 
1
∀x ∈ R, f (x) = √ exp − 1]− π2 , π2 [ (x)
2π(1 + x 2 ) 2

où 1 est la fonction indicatrice (elle vaut 1 si x est dans

l’intervalle, 0 sinon). Écrire la fonction f sous R.

Nicolas Baradel | Langage R

 Exercices
Énoncés 61

I On suppose avoir la matrice suivante :

I X <- cbind(c(1,2,1,3,2), c(121, 256, 842, 510, 82),
c(1, 2, 3, 4, 5), c(5, 11, 2, 7, 3))
I Trier la matrice par ordre croissant selon la première colonne et,
en cas d’égalité, selon la deuxième colonne (toujours par ordre
croissant).

Nicolas Baradel | Langage R

 Exercices
Correction 62

I f <- function(x)
{
if(x > -pi/2 && x < pi/2)
return( exp(-0.5*tan(x)2)/(sqrt(2*pi)*(1+x2)) )
return(0)
}
I X <- cbind(c(1, 2, 1, 3, 1), c(121, 256, 842, 510,
82), 1:5, c(5, 11, 2, 7, 3))
X <- X[order(X[, 1], X[, 2]), ]

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
63

I On dira qu’une fonction f est vectorielle si f prend un ou des

vecteurs en argument (et éventuellement d’autres arguments de
taille 1) et renvoie un vecteur où une fonction a été appliquée
élément par élément. C’est le cas par exemple de la fonction
sqrt ou exp.
I Soit la boucle de la forme :
I for(i in I)
I x[i] <- f(i,x[i],z[i])
I Si f est vectorielle alors cette boucle est toujours évitable, la
solution est :
I x <- f(1:length(x),x,z)

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
64

I Par exemple, si nous souhaitons affecter à x le carré de i, la

solution est
I x <- (1:length(x))2
I Ou alors, associer à xi l’exponentielle d’un élément zi d’un
vecteur z auquel on ajoute la constante 2, la solution est
I x <- exp(z) + 2
I Il se peut que nous souhaitions modifier x uniquement sur une
partie de ses indices. Par exemple, quelque chose de la forme
I for(i in I)
I if(h(i,x[i],z[i]))
I x[i] <- f(i,x[i],z[i])
I où h est une fonction vectorielle qui renvoie TRUE ou FALSE, f
n’est appliquée que sur un sous-ensemble de I où h est vérifiée

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
65

I Si f et h sont vectorielles alors cette boucle est toujours

évitable, la solution est :
I ind <- h(1:length(x),x,z)
I x[ind] <- f((1:length(x))[ind], x[ind], z[ind])

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
66

I Nous pouvons souhaiter modifier x uniquement sur les 30

premiers indices et leur affecter z, dans ce cas
I ind <- 1:length(x) <= 30
I x[ind] <- z[ind]
I Dans ce cas très simple nous aurions pu écrire
I x[1:30] <- z[1:30]
I Un autre exemple : nous souhaitons affecter la valeur 0 à tous
les indices où x vaut NA. Dans ce cas
I ind <- [Link](x)
I x[ind] <- 0
I Ici, ind n’est utilisé qu’une seule fois, nous aurions pu écrire
directement
I x[[Link](x)] <- 0

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
67

I Il ne faut pas être effrayé par le fait d’écrire x dans x. Ce qui est
à l’intérieur n’est que le calcul d’un vecteur de logical en
fonction de x (s’il vaut NA ou non).
I Ensuite, nous effectuons une opération dans les indices de x
vérifiant cette condition. Par exemple
I (x <- c(7, 2, NA, 3, -1, NA))
I [1] 7 2 NA 3 -1 NA
I x[[Link](x)] <- 0
I x
I [1] 7 2 0 3 -1 0

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
68

I Un autre exemple : là où la somme de x et y (deux vecteurs de

même taille) est supérieure à z, affecter à x le modulo de z par
2, sinon celui de y par 2
I ind <- x + y > z
I x[ind] <- z[ind]%%2
I x[!ind] <- y[!ind]%%2
I Rappel : le point d’exclamation est le NON logique, il inverse les
TRUE et FALSE
I Nous affectons, en fonction de x + y > z, à chaque élément, soit
z%%2, soit y%%2

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
69

I Un dernier exemple intervient dans la classification d’une

variable.
I Par exemple, si x est inférieur à un seuil a fixé, nous le mettons
dans la classe 0, s’il est supérieur à b, nous le mettons dans la
classe 2, et enfin s’il est entre les deux, dans la classe 1.
I y <- rep(1, length(x))
I y[x < a] <- 0
I y[x > b] <- 2

Nicolas Baradel | Langage R

 Programmation efficace
Le langage vectoriel
70

I Pour les conditions, les opérateurs && et || ne sont pas

vectoriels. Les versions vectorielles correspondantes sont & et |.
I Pour tester si une condition est vérifiée sur tous les éléments
d’un vecteur, on utilisera la fonction all.
I Pour tester si une condition est vérifiée sur au moins un élément
d’un vecteur, on utilisera la fonction any.

Nicolas Baradel | Langage R

 Exercices
Énoncés 71

I Retour sur un exercie passé : Écrire une fonction gammaEuler qui

approxime à l’ordre n ∈ N∗ la constante γ d’Euler définie par la
limite : !
n
X 1
γ = lim − log(n) .
n→+∞ k
k =1

On pourra vérifier avec -digamma(1) qui vaut γ. On veillera à ne

pas utiliser de boucle.

Nicolas Baradel | Langage R

 Exercices
Énoncés 72

I Retour sur un exercice passé : Soit X une variable aléatoire dont

la densité est définie par la fonction f :

tan2 (x)
 
1
∀x ∈ R, f (x) = √ exp − 1]− π2 , π2 [ (x)
2π(1 + x 2 ) 2

où 1 est la fonction indicatrice (elle vaut 1 si x est dans

l’intervalle, 0 sinon). Écrire cette fois-ci la fonction f de manière
vectorielle sous R afin qu’elle puisse prendre un vecteur x et
renvoie un vecteur de même taille f (x) où f est appliquée
élément par élément. On veillera à ne pas utiliser de boucle.

Nicolas Baradel | Langage R

 Exercices
Énoncés 73

I Écrire une fonction qui prend une matrice X = (xi,j ) de taille

n × m en argument et qui renvoie un vecteur de taille m où
l’élément j est la moyenne sur i de (cos(xi,j )i )1≤i≤n (attention,
bien voir que le cosinus est élevé à la puissance i).
I Écrire une fonction qui prend une matrice carrée X = (xi,j ) de
taille n × n en argument et renvoie la trace de la matrice X . La
trace de la matrice X est la somme des éléments diagonaux
définie par
n
Trace(X ) =
X
xk ,k .
k =1

Nicolas Baradel | Langage R

 Exercices
Correction 74

I gammaEuler <- function(n)

return( sum(1/(1:n)) - log(n) )
I f <- function(x)
{
y <- numeric(length(x))
ind <- x > -pi/2 & x < pi/2
z <- x[ind]
y[ind] <- exp( -0.5*tan(z)2 )/(sqrt(2*pi)*(1+z2))
return(y)
}

Nicolas Baradel | Langage R

 Exercices
Correction 75

I f <- function(X)
return( colMeans(cos(X)row(X)) )

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Le générateur aléatoire
76

I R utilise une suite de nombres pseudo-aléatoires générés par

une suite arithmétique.
I L’algorithme par défaut utilisé est le Mersenne- Twister. Sa
période est de 219937 − 1 ce qui vaut environ 106000 .
I Cet algorithme est souvent considéré comme le meilleur
compromis entre efficacité à simuler les variables aléatoires et
qualité du générateur (indépendance entre les simulations, la loi
simulée est bien la loi uniforme).
I Le générateur s’initialise tout seul
I Il est possible de choisir sa graîne avec [Link]
I Cela permet de reproduire les mêmes simulations à des fin de
debug.

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
77

À la loi d’une variable aléatoire, dont le nom donné par R est nom,
sont associées quatre fonctions :
I dnom
I pnom
I qnom
I rnom

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
78

I La première, dnom, prend en premier argument un nombre

décimal puis d’éventuels paramètres pour les arguments
suivants. Cette fonction évalue la densité de la loi nom en
l’argument passé en paramètre.
I Pour les variables aléatoires discrètes, cette densité est
P(nom = •) où • est le point en lequel dnom est évaluée. Dans le
cas des variables aléatoires continues, la densité est celle au
sens habituel du terme.

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
79

I La deuxième fonction, pnom, fonctionne comme dnom sauf qu’elle

n’évalue pas la densité mais la fonction de répartition
I La fonction qnom prend en premier argument un nombre α dans
l’intervalle [0,1] et lui associe le quantile d’ordre α de la loi nom
I Enfin, la fonction rnom permet de générer des simulations
indépendantes de la loi nom. Son premier argument est le
nombre souhaité de simulations

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
80

I La fonction dnom possède un argument facultatif log. Par défaut,

il vaut FALSE, mais s’il est mis à TRUE, ce n’est pas la densité qui
est renvoyée mais le logarithme de la densité
I Il est préférable d’écrire dnom(x, log = TRUE) que
log(dnom(x)), un exemple est donné dans le cas de la loi
normale
I Nous voyons maintenant les différentes lois sous R

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
81

I La loi uniforme U([a, b]) est nommée unif.

I Sa fonction densité évaluée en x = (xi )1≤i≤n s’évalue avec
dunif(x, a, b)
I Sa fonction de répartition s’évalue avec punif(x, a, b)
I Ses quantiles (avec xi ∈ [0, 1]) s’évalue avec qunif(x, a, b)
I La simulation de n ∈ N variables aléatoires i.i.d. se fait avec
runif(n, a, b)
I Nous ne donnons qu’après la fonction de simulation des lois, les
trois autres se déduisent de la même manière

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
82

I La loi binomiale B(m, p) : rbinom(n, m, p)

I La loi de Poisson P(a) : rpois(n, a)
I La loi géométroque issue de 0 G(p) : rgeom(n, p)
I La loi binomiale négative BN (m, p) : rnbinom(n, m, p)
I La loi normale N (m, s2 ) : rnorm(n, m, s)
I La loi du Khi-2 X (d) : rchisq(n, d)
I La loi de student St(d) : rt(n, d)

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Les quatre fonctions
83

I La loi log-normale LN (m, s2 ) : rlnorm(n, m, s)

I La loi exponentielle E(b) : rexp(n, b)
I La loi gamma G(a, b) : rgamma(n, a, b)
I La loi de Weibull W(a, b) : rweibull(n, a, b)
I La loi Beta B(a, b) : rbeta(n, a, b)
I La loi de Cauchy C(a, b) : rcauchy(n, a, b)
I La loi de Fisher F(d, k ) : rf(n, d, k)

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Ré-échantillonnage
84

I Ré-échantillonner, c’est créer un nouvel échantillon à partir d’un

échantillon initial
I Soit (xi )1≤i≤n , il s’agit de tirer uniformément dans l’échantillon
I Chaque xi a une probabilité de n1 , cela peut amener des valeurs
multiples
I Par défaut il n’y a pas de remise, il s’agit juste de tirer l’ordre
aléatoirement
I x <- c(1,2,3,5,8,13,21)
I sample(x)
[1] 8 2 3 21 1 13 5
I sample(x, replace = TRUE)
[1] 3 5 1 13 3 2 8
I sample(x, replace = TRUE, prob = c(0.3, 0.3, 0.1, 0.1,
0.1, 0.1, 0))
[1] 8 5 1 2 1 2 5
Nicolas Baradel | Langage R
 Simulation de variables aléatoires
Vecteurs gaussiens
85

I La fonction qui va nous permettre de simuler des vecteurs

gaussiens se situe dans le package MASS
I Ce package est déjà présent dans R, on le charge avec
library(MASS)
I La fonction qui va nous permettre de simuler des vecteurs
gaussiens est mvrnorm
I Lon premier argument est, comme d’habitude, le nombre n ∈ N
de simulations
I Le deuxième argument est un vecteur de taille d qui est le
vecteur moyenne dans Rd
I Le troisième argument est une matrice symétrique qui est la
matrice de variance-covariance dans Sd

Nicolas Baradel | Langage R

 Simulation de variables aléatoires
Vecteurs gaussiens
86

I Pour simuler n variables aléatoires de loi N (m, S) avec m ∈ Rd

et S ∈ S d , on utilise :
I library(MASS)
n <- 300
m <- c(1, 2)
S <- matrix(c(1,0.7,0.7,1), 2, 2)
X <- mvrnorm(n, m, S)
I X est une matrice à 2 colonnes et n lignes
I On peut obtenir la moyenne de chaque composante avec
colMeans et regarder la matrice de variance-covariance avec var

Nicolas Baradel | Langage R

 Exercices
Énoncés 87

I Estimons π par méthode de Monte-Carlo. Pour ce faire, prenons

le carré unité [−1; 1]2 et le disque de rayon 1 et de centre 0 de ce
carré. L’aire du carré est 4, l’aire du disque est π. Si on tire
uniformément dans le carré (ce qui revient à tirer deux lois
uniformes dans [-1,1], une étant l’axe des abscisses, l’autre l’axe
des ordonnées), la probabilité d’être dans le disque est π4 . Écrire
une fonction qui prend en argument le nombre de simulations n
et qui renvoie une estimation π.

Nicolas Baradel | Langage R

 Exercices
Énoncés 88

I Vérifions le théorème de la limite centrale. Simulez n échantillons

de taille m = 20 de loi G(α, β) avec (α, β) = (1, 1). Calculez la
moyenne de chacun des n échantillons de taille m, centrés
réduits avec la vraie moyenne et le vrai écart-type, et comparez
les quantiles de la distribution avec celle de la loi normale aux
ordre α = 0.5%, 1%, 5%, 25%, 50%, 75%, 95%, 99%, 99.5%

Nicolas Baradel | Langage R

 Exercices
Correction 89

I MCpi <- function(n)

{
return(4*mean(runif(n,-1,1)2 + runif(n,-1,1)2 <=
1))
}

Nicolas Baradel | Langage R

 Exercices
Correction 90

I n <- 106
m <- 25
X <- matrix(rgamma(n*m, 1, 1), n, m)
z <- sqrt(m)*(rowMeans(X) - 1)
p <- c(0.005, 0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 0.9,
0.95, 0.99, 0.995)
quantile(z, p)
qnorm(p)

Nicolas Baradel | Langage R

 Exercices
Correction 91

I X <-
[Link]("[Link]
header = TRUE, dec = ",", colClasses ="numeric")

Nicolas Baradel | Langage R

Fin du cours !