logiciel R

Initiation au logiciel
Mohammed Fekri
Institut National des Postes et Télécommunications
1 Introduction
Le logiciel est un langage de programmation et un environnement mathématique utilisé pour la

manipulation des données, les calculs et la représentation graphique. C’est un logiciel libre ; il est
distribué gratuitement par le CRAN (Compréhensive Archive Network) et tourne sur différent
système d’exploitation (Windows, Mac OS ou Linux). Vous pouvez le télécharger à l’adresse
suivante : http://cran.r-project.org. Il a été crée par R. Ihaka et R. Gentleman à l’université
d’Auckland (Nouvelle Zélande) et il est maintenant développé par la R development Core Team.
est un outil très puissant et très complet, particulièrement bien adapté pour la mise en oeuvre
de méthodes statistiques. Notons également que la plupart des méthodes avancées de statistique
et d’analyse de données sont aussi disponibles au travers de modules externes appelés packages,
qui sont regroupés sur le site du CRAN.
2 Utilisation sous windows
Lorsqu’on ouvre une session , les données de travail et les commandes utilisées seront enreg-
istrées à l’endroit où a été installé. Pour connaı̂tre le répertoire dans lequel travail, écrivez
dans la fenêtre de contrôle ( console) : getwd() qui signifie ”obtenir le répertoire de travail”.
Il est possible de changer ce répertoire de travail en tapant la commande setwd(".....") ou
bien dans le menu déroulant ”Fichier” il y a une option ”Changer le répertoire courant” qui par
l’intermédiaire d’une arborescence permet de choisir un répertoire.
En quittant , il vous propose de sauvegarder le travail effectué : Sauver une image de la
session ? [Oui / Non / Annuler]. En choisissant Oui, une icône sera alors créée dans le
répertoire de travail. En cliquant sur cette icône, une nouvelle session s’ouvrira directement dans
le répertoire concerné et les objets crées à la session précédente seront conservés.
Dans la fenêtre de contrôle de , on peut rentrer les instructions après le prompt >. On tape les
instructions (qui figurent en rouge), et le logiciel les exécute et affiche le résultat (en bleu). Il est
plus commode de saisir les instructions dans un fichier à l’aide de l’éditeur fourni dans le logiciel
1
Initiation au logiciel 3 LES OBJETS
dans le menu Fichier (choisir Nouveau script) ou avec un éditeur de texte de votre choix.
Pour exécuter ces instructions, on peut les copier et les coller dans la fenêtre de contrôle. Une
ligne tapée dans l’éditeur peut être recopiée dans la fenêtre de contrôle en cliquant sur le bouton
"Exécuter la ligne ou sélection" ou à l’aide du raccourci "Ctrl-R". Pour exécuter plusieurs lignes
à la fois, il suffit de les sélectionner. Vous pouvez également utiliser la fonction source("....")
de puis la fenêtre de contrôle pour aller lire et executer le contenu de votre fichier. Cela évitera
de surcharger inutilement votre console.
3 Les Objets
Les éléments de base de sont des objets qui peuvent être des données (vecteurs, matrices,
etc. . . ), des fonctions, des graphiques . . . . Les objets se différencient par leur mode, qui
décrit leur contenu et leur classe. Les objets atomiques sont de mode homogène et les objets
récursifs sont de mode hétérogène. Les différents modes sont :
null (objet vide), logical, numeric, complex, character
Les principales classes d’objets sont :
vector, matrix, array, factor, data.frame, list
Par défaut conserve en mémoire tous les objets crées dans la session. Il est donc recommandé
de supprimer régulièrement des objets. Pour connaı̂tre les objets de la session, on utilise les
fonctions objets() ou ls(). Pour supprimer l’objet x, on tape :
> rm(x)
et pour en supprimer plusieurs :
> rm(objet1,objet2)
Pour supprimer une liste d’objets qui possèdent une partie de leur nom en commun, par exemple
la lettre a, on utilise :
> rm(list=ls(pattern=".*a.*"))
c Mohammed Fekri 2
Initiation au logiciel 4 LES VECTEURS
4 Les Vecteurs
Les vecteurs sont extrêmement employés en et sont composés de données de mêmes types.
La création d’un vecteur peut se faire de différentes méthodes dont voici les principales :
• Construction par la fonction collecteur "c" :
> x <- c(-1.5, 2.8 , 12) # vecteur numérique de 3 éléments

> x
[1] -1.5 2.8 12.0
> x <- c(1,x,c(11,12)) # vecteur à 6 éléments
> x
[1] 1.0 -1.5 2.8 12.0 11.0 12.0
> x <- 12 # vecteur de longueur 1
> x
[1] 12
• Construction par l’opérateur séquence ":" :
> 1:10
[1] 1 2 3 4 5 6 7 8 9 10
• Construction par la fonction seq :
> seq(1,10,by=0.5)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0
[14] 7.5 8.0 8.5 9.0 9.5 10.0
> seq(1,10,length=5)
[1] 1.00 3.25 5.50 7.75 10.00
• Construction par la fonction rep :
> rep(1,6)
[1] 1 1 1 1 1 1
• En utilisant la fonction scan. demande alors d’entrer les éléments au fur et à mesure.
Avec l’argument n=4, on précise que quatre éléments seront collectés. Si on ne précise pas
n, on arrête de collecter en mettant une valeur vide.
c Mohammed Fekri 3
Initiation au logiciel 4 LES VECTEURS
> jeu1 <- scan(n=4)

1: 10
2: 25
3: 12
4: 11
Read 4 items
Il est possible de concaténer deux vecteurs (formés de variables de même type) pour en former
un nouveau vecteur :
> x <- c(1,3,5,9)

> y <- c(11,13,15,19)
> z <- c(x,y)
> z
[1] 1 3 5 9 11 13 15 19
Il est aussi possible de sélectionner une partie d’un vecteur avec l’opérateur [ ] et un vecteur de
selection :
> x <- 1:20

> x[10] # donne la dixième composante de x
> x[8:6] # donne la huitième, septième et sixième composante de x
> x[c(20,20,1:3)]
[1] 20 20 1 2 3
> x[-c(11:20)] # donne x sans ses dix dernières composantes
> x[-c(1,3)] # donne x sans la première et la troisième composante
> x[(x < 15) & (x > 10)] # & signifie "et"
[1] 11 12 13 14
> x[(x < 8) | (x > 14)] # | signifie "ou"
[1] 1 2 3 4 5 6 7 15 16 17 18 19 20
> which(abs(x^2-111)>15)
[1] 1 2 3 4 5 6 7 8 9 12 13 14 15 16 17 18 19 20
Pour donner un nom à chaque composante d’un vecteur, on peut utiliser la commande :
> notes.etudiant1 <- c(Maths=18, Info=16, Phys=13)

> notes.etudiant1
Maths Info Phys
18 16 13
c Mohammed Fekri 4
Initiation au logiciel 5 LES MATRICES
ou bien :
> notes1 <- c(18, 16, 13)

> matieres <- c("Maths", "Info", "Phys")
> names(notes1) <- matieres
> notes1
Maths Info Phys
18 16 13
Pour supprimer les noms :
> names(notes1) <- NULL
Pour classer les composantes d’un vecteur par ordre croissant en utilise la fonction sort
> sort(notes1)
[1] 13 16 18
ou dans l’ordre décroissant :
> rev(sort(notes1))
[1] 18 16 13
5 Les Matrices
Comme pour les vecteurs, les matrices sont des objets atomiques, c’est-à-dire de même type
pour toutes les valeurs. Une matrice est créée à partir d’un vecteur contenant les valeurs, et
d’un nombre de ligne (nr ou nrow, pour Number of Row) et/ou de colonne (nc ou ncol, pour
Number of Column) :
> M <- matrix(1:9,nr=3)

> M
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
Noter que par défaut rempli les matrices valeur par valeur. Pour remplir les éléments ligne
par ligne, on utilise l’argument byrow=T :
c Mohammed Fekri 5
> M <- matrix(1:9,nr=3,byrow=T)

> M
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 4 5 6
[3,] 7 8 9
Si la longueur du vecteur est différente du nombre d’éléments de la matrice (nr × nc) alors
l’opération effectuée par est la suivante :
• Si le vecteur est trop grand, la matrice est construite à partir des premiers éléments :
> matrix ( c ( 1.5,2,3.1,8 ) , nr=1,nc=2)

[,1] [,2]
[1,] 1.5 2
• Si le vecteur est trop petit, le répète (suivant les possibilités de replication) :
> matrix ( c ( 1.5,2,3.1,8 ) , nr=2,nc=3)

[,1] [,2] [,3]
[1,] 1.5 3.1 1.5
[2,] 2.0 8.0 2.0
Message d’avis :
In matrix(c(1.5, 2, 3.1, 8), nr = 2, nc = 3) :
la longueur des données [4] n’est pas un diviseur ni un multiple du
nombre de colonnes [3]
> matrix ( c ( 1.5,2,3.1,8 ) , nr=2,nc=4)

[,1] [,2] [,3] [,4]
[1,] 1.5 3.1 1.5 3.1
[2,] 2.0 8.0 2.0 8.0
> matrix ( c ( 1.5,2,3.1,8 ) , nr=5,nc=4)

[,1] [,2] [,3] [,4]
[1,] 1.5 2.0 3.1 8.0
[2,] 2.0 3.1 8.0 1.5
[3,] 3.1 8.0 1.5 2.0
[4,] 8.0 1.5 2.0 3.1
[5,] 1.5 2.0 3.1 8.0
On peut aussi utiliser la fonction scan pour construire une matrice en introduisant les éléments
un par un :
c Mohammed Fekri 6
> matr <- matrix(scan(),ncol=3)

1: 1 2 3
4: 4 5 6
7: 7 8 9
10:
Read 9 items
> matr
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
Un vecteur n’est pas considéré par comme une matrice. Cependant, la fonction as.matrix
permet de transformer un vecteur en une matrice unicolonne :
> v <- c ( 1.5,2,3.1,8 )

> v
[1] 1.5 2.0 3.1 8.0
> as.matrix(v)
[,1]
[1,] 1.5
[2,] 2.0
[3,] 3.1
[4,] 8.0
Il est possible d’attribuer des noms aux lignes et aux colonnes avec rownames() et colnames() :
> colnames(matr) <- c("C1","C2","C3")

> rownames(matr) <- c("L1","L2","L3")
> matr
C1 C2 C3
L1 1 4 7
L2 2 5 8
L3 3 6 9
L’emplacement d’un élément, une ou plusieurs lignes et/ou une ou plusieurs colonnes d’une
matrice est en général donné par les numéros des lignes et des colonnes :
> matr[i,j] # l’élément (i,j) de la matrice matr

> matr[i,] # retourne la ligne i sous la forme d’un vecteur
Pour récupérer la ligne i sous la forme d’une matrice uniligne et non plus d’un vecteur, on utilise :
c Mohammed Fekri 7
> matr[i,,drop=FALSE]
> matr[c(1,1,2,3),] # donne la première, la première, la seconde

# et la troisième ligne
> matr[-1,] # matrice sans sa première ligne
> matr[-1,c(1,2)] # les deux premières colonnes de matr sans sa première ligne
La fonction cbind (resp. rbind) permet de concaténer des colonnes (resp. des lignes) :
> cbind(matr,c(10,11,12))
[,1] [,2] [,3] [,4]
[1,] 1 4 7 10
[2,] 2 5 8 11
[3,] 3 6 9 12
> rbind(matr,c(10,11,12))
[,1] [,2] [,3]
[1,] 1 4 7
[2,] 2 5 8
[3,] 3 6 9
[4,] 10 11 12
La fonction apply permet d’appliquer une fonction aux lignes (MARGIN=1) ou aux colonnes
(MARGIN=2) de la matrice :
> apply(matr,2,mean) # moyennes par colonne
[1] 2 5 8
> apply(matr,1,sum) # sommes par ligne
[1] 12 15 18
Le tableau suivant résume quelques fonctions utiles pour les matrices :
A%*%B Produit de matrices

t(A) Transposée de la matrice A
diag(3) Matrice identité d’ordre 3
diag(x) Matrice diagonale avec le vecteur x sur la digonale
kronecker(A,B) ou A%x%B Produit de kronecker
det(A) Déterminant de la matrice A
svd(A) Décomposition en valeurs singulières
eigen(A) Diagonalisation d’une matrice
crossprod(A,B) Produit croisé (t(A)%*%B)
solve(A) Inverse de A
solve(A,a) Résolution de système linéaire
chol(X) Décomposition de Cholesky
qr(X) Décomposition QR
sum(diag(A)) Trace de la matrice A
c Mohammed Fekri 8
Initiation au logiciel 6 GRAPHIQUES
Par exemple pour résoudre le système suivant :


 x + 2y + 5z = 4
2x + y + 2z = 2
3x + 2y + z = 1

qui revient à écrire :
> A <- matrix(c(1,2,3,2,1,2,5,2,1),ncol=3)

> d <- c(4,2,1)
> solve(A,d)
[1] -0.9 4.2 -0.7
La solution est donc x = −0.9, y = 4.2 et z = −0.7.
6 Graphiques
Les possibilités graphiques de sont particulièrement simples à utiliser et offrent une multitude
d’options pour les personnaliser. La façon la plus simple de produire des graphiques sous est
d’utiliser la fonction plot. par exemple,
2pour
représenter à intervalles réguliers les points de la
1 x
courbe de la fonction x 7−→ √2π exp − 2 sur [−3, 3], on utilise les commandes suivantes :
> xi <- seq(-3,3,length=100)

> fx <- 1/sqrt(2*pi)*exp(-xi^2/2)
> plot(xi,fx) # Essayer aussi type="l" ou type="s" ou type="h"
Les graphiques peuvent être sauvegardés en pdf, ps, jpeg, . . . . Si on veut faire apparaı̂tre plusieurs
graphiques dans la même fenêtre, on utilise la fonction par.
L’instruction par(mfrow=c(n,p)) organise np graphiques en n lignes et p colonnes. On peut
aussi avoir besoin d’ouvrir plusieurs fenêtres graphiques, on utilise pour cela X11() ou windows().
Afin d’améliorer un graphique, il est possible :
• d’utiliser des couleurs
> plot(x,y, pch=3,col="blue")
• > text(x,y,labels,...) # ajoute du texte dans un graphique
• > abline(h=a) # ajoute une droite d’équation y=a à un graphique

déjà existant (doit suivre une commande plot())
c Mohammed Fekri 9
Initiation au logiciel 6 GRAPHIQUES
0.4
●●
●● ●●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
0.3
● ●
● ●
● ●
● ●
● ●
● ●
● ●
0.2
fx
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
0.1
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●●
●● ●●
●● ●●
●●●●●● ●●●
●●●●
0.0
●●
−3 −2 −1 0 1 2 3
xi
2
nuage de points de la fonction x 7−→ √1 exp − x2
2π
• > abline(v=a) # ajoute une droite d’équation x=a

• > abline(c(b,a)) # ajoute une droite d’équation y=ax+b
On trouve la documentation de tous les paramètres graphiques via help(par).
Par ailleurs, voici une liste d’arguments que l’on utilise fréquemment :
Argument Description
pch entier entre 0 et 25 qui contrôle le type de symbole ou
éventuellement n’importe quel caractère entre guillemets
lty=n contrôle le style de la ligne tracée (n=1 : continue, n=2 : tirets,
n=3 : points, n=4 : points et tirets alternés, n=5 : tirets longs,
n=6 : tirets courts et longs aternés)
cex=x conrôle la taille des caractères et des symboles. x=1 est la valeur
par défaut
xlim=c(a,b) contrôle les limites pour les axes x et y. Souvent utilisé pour faire
ylim=c(a,b) plusieurs graphiques à la même échelle
xlab, ylab permet de donner des noms aux axes. Par défaut, ce sont les noms
des variables x et y qui sont utilisées
main précise le titre du graphe
mfrow=c(n,p) organise np graphiques en n lignes et p colonnes
lwd contrôle l’épaisseur des traits
pos précise la position du texte (valeurs permises 1, 2, 3, 4) par exemple
text(x,y,expression(paste(alpha)),pos=3)
c Mohammed Fekri 10
Initiation au logiciel 7 LES LOIS USUELLES
7 Les Lois Usuelles
Un certain nombre de lois de probabilité usuelles ont été implémentées dans . Toutes les
fonctions commencent par les lettres d, p, q ou r et se terminent par une abréviation du nom de
la loi.
La lettre d signifie que la fonction calcule la probabilité ponctuelle (pour les v.a.d.), ou la densité
(pour les v.a.c.), la lettre p signifie que la fonction calcule la fonction de répartition, la lettre q
signifie que la fonction calcule un quantile et la lettre r signifie que la fonction génère un nombre
pseudo-aléatoire.
Voici un tableau qui décrit quelques lois standards ainsi que les paramètres par défaut quand ils
existent :
Nom de la loi Nom sous Paramètres Valeurs par défaut

Beta beta shape1, shape2
Binomiale binom size, prob
Cauchy cauchy location, scale 0, 1
Chi-deux chisq df
Exponentielle exp 1/mean
Fisher f df1, df2
Gamma gamma shape, 1/scale ..., 1
Géometrique geom prob
Hypergéometrique hyper m, n, k
Log-Normale lnorm mean, sd 0, 1
Logistic logis location, scale 0, 1
Normale norm mean, sd 0, 1
Poisson pois lambda
Student t df
Uniforme unif min, max 0, 1
Weibull weibull shape, scale
Lorsqu’on génère une suite de nombres au hasard, il se peut que nous ayons besoin de reproduire
exactement la même suite de nombres, par exemple pour comparer deux procédures. Dans ce cas
on doit indiquer la graine de départ (seeds) qui permet d’initialiser la suite de réalisation
avec la commande set.seed().
c Mohammed Fekri 11
Fonction Description
pnorm(x) donne la fonction de répartition de la loi N (0, 1) au point x (Φ(x))
dnorm(x,m,σ) donne la densité de la loi loi N (m, σ 2 ) au point x
qnorm(α) donne le quantile d’ordre α de la loi N (0, 1) (Φ−1 (x))
rnorm(n,m σ) donne n réalisation de la loi N (m, σ 2 )
dbinom(k,n,p) donne P {X = k} où X suit une loi B(n, p)
pbinom(k,n,p) donne P {X ≤ k} où X suit une loi B(n, p)
dgeom(k,p) donne P {X = k} = p(1 − p)k
sample(x,n) permet de choisir au hasard n éléments du vecteur x sans remise
(avec remise repl=TRUE)
Il y a des techniques (cf. ch. 5, cours de Probabilités) qui permettent de traiter des lois qui ne
sont pas disponibles dans la librairie de base de .
Exemple : Simulation de n réalisations d’une variable aléatoire discrète
Soit X une variable aléatoire de loi donnée par :
P {X = 1} = 0.05, P {X = 2} = 0.1, P {X = 4} = 0.35,
P {X = 6} = 0.4, P {X = 8} = 0.1.
> debut <- proc.time()[3]

> x <- NULL
> for (i in 1:n){
u=runif(1)
if (u < .05)
x[i] <- 1
else if (u < .15)
x[i] <- 2
else if (u < .5)
x[i] <- 4
else if ( u< .9)
x[i] <- 6
else
x[i] <- 8
}
> cat("Temps écoulé :", proc.time()[3]-debut,"seconds")
ou en profitant de la souplesse de la syntaxe :

> x <- NULL
> u <- runif(n)
> x[u <= .05] <- 1
c Mohammed Fekri 12
> x[u <= .15 & u > 0.05] <- 2

> x[u <= .5 & u > 0.15] <- 4
> x[u <= .9 & u > 0.5] <- 6
> x[u > 0.9] <- 8
ou encore :
> x <- sample(c(1,2,4,6,8), n , repl=TRUE, prob=c(.05,.15,.35,.4,.1))
Exemple : Quelques modes de convergence
• Loi faible des grands nombres :
> p <- 0.25

> LFAGN <- function(n,eps){
pbinom(n*p+n*eps,n,p) - pbinom(n*p-n*eps,n,p)
}
> LFAGN(100,0.1)
[1] 0.9795098
> LFAGN(100,0.01)
[1] 0.1800686
> LFAGN(1000,0.01)
[1] 0.5342356
> LFAGN(10000,0.01)
[1] 0.9790828
> LFAGN(20000,0.01)
[1] 0.9989098
1.0
0.8
0.6
LFAGN(n, 0.01)
0.4
0.2
0.0
0 5000 10000 15000 20000
c Mohammed Fekri 13
• Loi forte des grands nombres :
> LFOGN <- function(n,p){

cumsum(ifelse(runif(n) < p , 1,0))/(1:n)
}
> plot(LFOGN(10000,0.25),type="l",xlab=expression(italic(n)),lwd=3)
> abline(h = p, lty=1,col="red",lwd=2)
0.30
0.25
0.20
x
0.15
0.10
0.05
0.00
0 2000 4000 6000 8000 10000
n
• Théorème central limite :
> CLT <- function(n,p){

sqrt(n/(p*(1-p)))*(mean(rbinom(n,1,p))-p)
}
> simlist <- replicate(10000,CLT(1000,0.25))

> hist(simlist,prob=TRUE)
> curve(dnorm(x),-4,4,add=TRUE,lwd=2)
0.4
0.3
Density
0.2
0.1
0.0
−4 −2 0 2 4
c Mohammed Fekri 14
Initiation au logiciel 8 LES FONCTIONS
8 Les Fonctions
Les fonctions sont des objets qui permettent de découper un programme en un ensemble
d’actions. Un grand nombre de fonctions sont prédéfinies dans . Voici une liste de quelques
fonctions :
space*0.22cmmean(vecteur) calcule la moyenne

var(vecteur) calcule la variance
sd(vecteur) calcule l’écart type
summary(tableau) affiche un résumé du tableau
length(vecteur) retourne le nombre de cases d’un vecteur
ncol(tableau) retourne le nombre de colonnes d’un tableau
nrow(tableau) retourne le nombre de lignes d’un tableau
min(vecteur) retourne la plus petite valeur d’un vecteur
max(vecteur) retourne la plus grande valeur d’un vecteur
sort(vecteur) retourne une copie d’un vecteur après l’avoir trié
median(vecteur) calcule la médiane
sqrt(nombre) retourne la racine carré d’un nombre
sum(vecteur) retourne la somme de toutes les valeurs du vecteur
rank(vecteur) retourne un vecteur avec les rangs (c’est à dire avec 1 pour la plus
petite valeur, 2 pour la seconde, etc...)
Le tableau suivant fourni quelques fonctions mathématiques classiques :
Nom Description Exemple Résultat

x%%y Reste de la division de x par y 9%%4 1
ceiling() Plus petit entier relatif supérieur ou égal a x ceiling(4.2) 5
trunc() Partie entière de x trunc(4.2) 4
round() Arrondit les valeurs de son premier paramètre d’appel round(5.1235478,4) 5.1235
a un certain nombre de décimales spécifiées
par le second paramètre d’appel
signif() Arrondit les valeurs de son premier paramètre signif(5.1235478,4) 5.124
d’appel a un certain nombre de chiffres significatifs
sign() Signe±1 sign(-10) -1
abs(x) Valeur absolue |x| |-10| 10
exp() Exponentielle ex exp(0) 1
log() Logarithme népérien
√ log(1) 0
sqrt() Racine carrée x sqrt(9) 3
range() Étendue range(c(10,6,3,8)) 3 10
max() Maximum max(10,6,3,8) 10
min() Minimum min(10,6,3,8) 3
sum() Somme de ses paramètres effectifs sum(10,6,3,8) 27
prod() produit de ses paramètres effectifs prod(10,6,3,8) 1440
cumsum() Sommes cumulées cumsum(c(3,6,10,8)) 3 9 19 27
cumprod() Produit cumulés cumprod(c(3,6,10,8)) 3 18 180 1440
beta() Fonction beta β(a, b) beta(1,2) 0.5
lbeta() Logarithme de la fonction beta lbeta(1,1) 0
factorial() Factorielle n! factorial(4) 24
n!
choose() Coefficients du binôme Ckn = k!(n−k)! choose(3,4) 4
gamma() Fonction gamma Γ(x) gamma(5) 24
lgamma() Logarithme de la fonction gamma lgamma(2) 0
digamma() derivée du logarithme de la fonction gamma digamma(5) 1.506118
trigamma() derivée seconde du logarithme de la fonction gamma trigamma(5) 0.221323
c Mohammed Fekri 15
Initiation au logiciel 8 LES FONCTIONS
Pour connaı̂tre les fonctions prédéfinies de il suffit de taper :
> ls("package:base")
L’aide en ligne de est particulièrement bien faite. Elle comprend une description de la fonction,
son utilisation, la liste des arguments avec une explication de leur usage, des exemples et les valeurs
par défauts.
Une fonction admet des arguments en entrée et retourne un résultat en sortie. Les arguments
sont soit obligatoires soit optionnels. Dans ce dernier cas, ils possèdent une valeur par défaut. Par
exemple, la fonction runif qui génère des nombres pseudo-aléatoires suivant une loi uniforme.
Cette fonction admet trois arguments : n le nombre de valeurs, min la borne inférieure et max
la borne supérieure. Ces deux derniers sont fixés par défaut à 0 et 1. Pour retrouver les mêmes
résultats d’une simulation à l’autre, il faut fixer la graine du générateur de nombres pseudo-
aléatoire en utilisant la commande set.seed() à une valeur quelconque.
> set.seed(2014) # fixe la gaine du générateur

> runif(n=4)
[1] 0.2858056 0.1689087 0.6259122 0.3096863
Ces quatre nombres ont été tirés selon une loi uniforme U[0,1] . Si on veut tirer trois nombres selon
une loi uniforme U[1,4] , on utilise :
> set.seed(2014) # fixe la gaine du générateur

> runif(n=4,min=1,max=4)
[1] 1.857417 1.506726 2.877737 1.929059
Il n’est pas indispensable de préciser le nom des arguments à condition de respecter leur ordre.
Cet ordre est défini lors de la création de la fonction. la fonction args renvoie les arguments
d’une fonction :
> args(runif)
function (n, min = 0, max = 1)
NULL
Il est possible d’écrire soit même des fonctions personnalisées soit directement au départ de la
console, soit en utilisant un éditeur de texte. La seconde possibilité permet la correction du code
en cours d’édition, tandis que la première s’effectue ligne par ligne sans retour en arrière possible.
Voici un exemple simple, avec la syntaxe à utiliser :
c Mohammed Fekri 16
Initiation au logiciel 9 PROGRAMMATION EN R
> nom_Fonction <- function(x,y) {

resultat <- (x+y)^2 + sqrt(x)/y^3
resultat
}
Les accolades signalent à l’interpréteur de commande le début et la fin du code source de la

fonction ainsi définie. La dernière instruction doit contenir le nom de l’objet renvoyé par la
fonction. Avant de pouvoir appeler cette fonction dans la fenêtre de contrôle, il faut l’évaluer.
Pour cela, il suffit de la copier dans la fenêtre de contrôle.
> nom_Fonction(1,3)
[1] 16.03704
9 Programmation en R
Sous un groupe de commandes est délimité par des accolades :
> {
+ expression1
+ expression2
+ ...
}
Deux commandes successives sont séparées par un retour à la ligne. Cependant, il est possible
d’écrire plusieurs commandes sur une même ligne en les séparant par ;.
> { expression1 ; expression2 ; .....}
Les boucles :
Les structure classique de contrôle (alternatives et répétitives) sont disponible sous . Com-
mençons par la boucle for.
for (compteur in sequence)
le compteur est initialiser dans cette fonction. Il prend, au premier passage, la première valeur
de l’objet sequence. Dans le deuxième passage, le compteur prend la deuxième et . . . jusqu’à ce
que tous les éléments du vecteur sequence soient passés dans la boucle. Cette boucle est utilisé
lorsqu’on connaı̂t à l’avance la série de valeurs que devra prendre le compteur.
c Mohammed Fekri 17
Exemple : Une boucle qui met x au carré 4 fois.
> x <- 3
> for (i in 1:4){
x <- x^2
cat(x,"\t")
}
Exemple : Suite de Fibonacci
n <- 30 ; fibona <- numeric(n) ; fibona[1:2] <- 1

for (i in 3:n){
fibona[i] <- fibona[i-1] + fibona[i-2]
}
> fibona[n-1]
[1] 514229
Exemple : Approximation du nombre d’or.
> or <- fibona[2:n]/fibona[1:(n-1)]

> plot(1:14,or[1:14],main="Approximation du nombre d’or")
> abline(h=or[n-1],col="red",lwd=2)
> or[n-1]
[1] 1.618034
Une autre possibilité de boucle est la fonction while. Sa syntaxe est la suivante
> while (condition){ expression1 ; expression2 ; ... }
Les ordres expression1 ; expression2 ; ... sont effectués tant que la condition est
vraie, celle-ci étant évaluée en début de la boucle. Dès que la condition est fausse, la boucle est
arrêtée. Cette boucle est utilisée lorsqu’on ne sait pas combien de boucles nous devons effectuer.
> i <- 1
> while (i <= 10){
cat(i, "\n")
i <- i+2
}
permet d’afficher i et de l’augmenter de 2 tant que i est inférieur ou égale à 10.
c Mohammed Fekri 18
Approximation du nombre d'or
2.0
●
1.8
●
1.6 ● ● ● ● ● ● ● ● ●
●
or[1:14]
●
1.4
1.2
1.0
2 4 6 8 10 12 14
1:14
Exemple : Suite de Fibonacci.
> F <- c(1, 1)

> n <- 2
> while (F[n] <= 100) {

cat("n =", n, " F[n] =", F[n], "\n")
n <- n + 1
F[n] <- F[n-1] + F[n-2]
}
> cat("Le premier nombre de Fibonacci > 100 est F(", n, ") =", F[n], "\n")
Le premier nombre de Fibonacci > 100 est F( 12 ) = 144
> F
[1] 1 1 2 3 5 8 13 21 34 55 89 144
Une autre possibilité de boucle est la fonction repeat. Dans ce cas la sortie de boucle est assurée
par la fonction break.
> i <- 1
> repeat {
cat(i, "\n")
c Mohammed Fekri 19
i <- i+2
if (i==9) break
}
Les conditions if, else :

L’instruction if permet d’exécuter un bloc d’instructions sous la condition qu’une certaine ex-
pression logique soit vraie. Elle prend la forme :
if(condition) {expession1 ; expression2 ; ... } else {expession3 ; expression4 ; ... }
comme par exemple :
> if(x>=0) {sqrt(x)} else {cat("x est négatif")}.
Cette instruction teste si x est positif, si c’est le cas, la racine carrée est calculée, sinon le message
”x est négatif” s’affiche :
> x <- 25
> if (x >= 0) sqrt(x) else cat("x est négatif")
[1] 5
Notez que le bloc de commandes doit être entre accolades { } s’il comprend plus d’une commande.
De plus, la partie else {expession3 ; expression4 ; ... } n’est pas obligatoire quand
aucune action n’est requise si la condition est fausse.
racines <- function(a,b,c){

discriminant <- b^2 - 4*a*c
if (discriminant > 0) {
racines <- c( (-b + sqrt(discriminant))/(2*a) ,
(-b - sqrt(discriminant))/(2*a) )
} else {
if (discriminant == 0) {
racines <- -b/(2*a)
} else {
racines <- c()
}
}
show(racines)
}
c Mohammed Fekri 20
Exemple : Deux personnes J1 et J2 participent à un jeu avec des probabilités respectives de

victoire à chaque partie p (p = 0.2) et q = 1 − p. Le gagnant est celui qui le premier obtient
deux victoires de plus que l’autre. Donner une approximation de la probabilité de gain de J1 ?
> n=10000
> res=numeric(n)
> for (j in 1:n){
A=0 ; p=0.2
Jeu=c(A)
while(A<=1 & A>=-1)

{
ProbVal=sample(c(0,1),prob=c(1-p,p),1)
if(ProbVal == 1)
{
A = A+1;
}else{A=A-1}
Jeu=c(Jeu,A)
}
res[j]=A
}
> mean(res==2)
Exemple : Vérifier si un nombre est premier ou non.

> premier <- function(n) {
# TRUE si n est premier
# n est un entier positif
if (n == 1) {
nb.premier <- FALSE
} else if (n == 2) {
nb.premier <- TRUE
} else {
nb.premier <- TRUE
m <- 2
m.max <- sqrt(n)
while (nb.premier && m <= m.max) {
if (n %% m == 0) nb.premier <- FALSE
m <- m + 1
}
}
return(nb.premier)
}
La fonction ifelse est une généralisation vectorielle des commandes if et else. Elle applique
une condition aux éléments d’un object et créée un object du même type rempli par des éléments
dépendant du résultat du test sur chaque élément de départ.
c Mohammed Fekri 21
> ifelse(runif(100) < 0.2 , 1, 0)

Lorsque cela est possible, il est preferable d’éviter l’utilisation de boucles en , car cela en-
traı̂ne souvent un accroissement du temps de calcul (qui peut être mesuré grâce à la fonction
system.time()). La plupart des opérations en sont en effet vectorisées, c’est-a-dire qu’elles
peuvent opérer sur des vecteurs, ce qui est beaucoup plus rapide.
> system.time(for (n in (1:1000000)) sqrt(n))

utilisateur système écoulé
0.41 0.00 0.40
> system.time(sqrt(1:1000000))
utilisateur système écoulé
0.01 0.00 0.02
Exemple : Représentation graphique des triangles de Sierpinsky

√
Tracer le triangle A(−10, 0), B(10, 0), C(0, 10 3). Placer un point M0 quelconque dans ce
triangle. Pour placer les points suivants que l’on note Mi : on tire un nombre entier a au hasard
entre 1 et 3. Si a = 1 le point Mi sera le milieu du segment [AMi−1 ], si a = 2 le point Mi sera
le milieu du segment [BMi−1 ] et si a = 3 le point Mi sera le milieu du segment [CMi−1 ], et ainsi
de suite . . .
triangleS <- function(nbsim, xM, yM){

xA <- -10 ; yA <- 0 ; xB <- 10 ; yB <- 0 ; xC <- 0 ; yC <- 10 * sqrt(3)
plot(c(xA, xB, xC), c(yA, yB, yC),main="TRIANGLES DE SIERPINSKY",
xlab="",ylab="")
lines(c(xA, xB, xC, xA), c(yA, yB, yC, yA))
points(xM, yM, pch = "*") ; x <- xM ; y <- yM
for(i in 1:nbsim){
a <- sample(1:3, 1)
if(a == 1){
x <- (xA + x) / 2 ; y <- (yA + y) / 2
points(x, y, pch = ".", col = "green")
} else {
if(a == 2){
x <- (xB + x) / 2 ; y <- (yB + y) / 2
points(x, y, pch = ".", col = "red")
} else {
x <- (xC + x) / 2 ; y <- (yC + y) / 2
points(x, y, pch = ".", col = "blue")
}
}
}
}
c Mohammed Fekri 22
TRIANGLES DE SIERPINSKY
●
15
10
5
● ●
0
−10 −5 0 5 10
c Mohammed Fekri 23

logiciel R

Transféré par

Droits d'auteur :

Formats disponibles

logiciel R

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

logiciel R

Transféré par

Droits d'auteur :

Formats disponibles

Initiation au logiciel

Institut National des Postes et Télécommunications

Le logiciel est un langage de programmation et un environnement mathématique utilisé pour la

2 Utilisation sous windows

null (objet vide), logical, numeric, complex, character

Les principales classes d’objets sont :

vector, matrix, array, factor, data.frame, list

et pour en supprimer plusieurs :

• Construction par la fonction collecteur "c" :

> x <- c(-1.5, 2.8 , 12) # vecteur numérique de 3 éléments

• Construction par l’opérateur séquence ":" :

• Construction par la fonction seq :

• Construction par la fonction rep :

> jeu1 <- scan(n=4)

> x <- c(1,3,5,9)

> x <- 1:20

> notes.etudiant1 <- c(Maths=18, Info=16, Phys=13)

> notes1 <- c(18, 16, 13)

Pour supprimer les noms :

> names(notes1) <- NULL

ou dans l’ordre décroissant :

> M <- matrix(1:9,nr=3)

> M <- matrix(1:9,nr=3,byrow=T)

> matrix ( c ( 1.5,2,3.1,8 ) , nr=1,nc=2)

• Si le vecteur est trop petit, le répète (suivant les possibilités de replication) :

> matrix ( c ( 1.5,2,3.1,8 ) , nr=2,nc=3)

> matrix ( c ( 1.5,2,3.1,8 ) , nr=2,nc=4)

> matrix ( c ( 1.5,2,3.1,8 ) , nr=5,nc=4)

> matr <- matrix(scan(),ncol=3)

> v <- c ( 1.5,2,3.1,8 )

> colnames(matr) <- c("C1","C2","C3")

> matr[i,j] # l’élément (i,j) de la matrice matr

> matr[c(1,1,2,3),] # donne la première, la première, la seconde

Le tableau suivant résume quelques fonctions utiles pour les matrices :

A%*%B Produit de matrices

Par exemple pour résoudre le système suivant :

qui revient à écrire :

> A <- matrix(c(1,2,3,2,1,2,5,2,1),ncol=3)

La solution est donc x = −0.9, y = 4.2 et z = −0.7.

> xi <- seq(-3,3,length=100)

Afin d’améliorer un graphique, il est possible :

• d’utiliser des couleurs

> plot(x,y, pch=3,col="blue")

• > text(x,y,labels,...) # ajoute du texte dans un graphique

• > abline(h=a) # ajoute une droite d’équation y=a à un graphique

• > abline(v=a) # ajoute une droite d’équation x=a

7 Les Lois Usuelles

Nom de la loi Nom sous Paramètres Valeurs par défaut

Exemple : Simulation de n réalisations d’une variable aléatoire discrète

Soit X une variable aléatoire de loi donnée par :

P {X = 1} = 0.05, P {X = 2} = 0.1, P {X = 4} = 0.35,

> debut <- proc.time()[3]

ou en profitant de la souplesse de la syntaxe :

> debut <- proc.time()[3]

> x[u <= .15 & u > 0.05] <- 2

> p <- 0.25

0 5000 10000 15000 20000

• Loi forte des grands nombres :

> LFOGN <- function(n,p){

0 2000 4000 6000 8000 10000