introduction objet dans le sexe

Master Mathématiques et Applications
Spécialité Statistique
Septembre 2016
Fiche 1
Introduction à R
1
Introduction
On commencera par ouvrir une session sous RStudio. Une fois la session ouverte, R attend une
instruction, ce qu’indique le signe ”>” en début de ligne. Chaque instruction doit être validée par
Entrée pour être exécutée. Si l’instruction est correcte, R redonne la main, ce qu’indique ”>”. Si
l’instruction est incomplète, R retourne le signe ”+”. Il faut alors compléter l’instruction ou sortir
de cette situation et récupérer la main en tapant Ctrl + c ou Echap. Si l’instruction est erronée,
un message d’erreur apparaı̂t. La création d’un objet peut se faire par affectation avec un des trois
opérateurs “<-”, “->”, “=” en donnant un nom à cet objet :
> x<-2016
2
Création d’objets
2.1
Scalaires
— calculs directs :
> 2+3
> 3^2-5*log(100)+sqrt(8)
— création :
> x<-2*cos(-5)
> y<-pi^2
> x*y
> a<-cos(x*y)
> a
> a<-sqrt(a)
> a
2.2
Scalaires chaı̂nes
> x<-"il fait"
> y<-"beau"
> paste(x,y)
2.3
2.3.1
Vecteurs
Création
Pour construire un vecteur, différentes méthodes sont possibles. Voici les principales :
1
— Construction par la fonction collecteur c :
> x <- c(5.6,-2,78,42.3)
> x
> x <- c(x,3,c(12,8))
> x
— Construction par l’opérateur séquence “ :” :
> 1:6
— Construction par la fonction seq (séquence régulière) :
> seq(1,6,by=0.5)
> seq(1,6,length=5)
— Construction par la fonction rep (réplication) :
> rep(1,4)
> rep(c(1,2),each=3)
2.3.2
Extraction
L’extraction s’effectue à partir des indices des éléments du vecteur que l’on souhaite extraire :
>
>
>
>
x<-15:25
x[2]
x[2:5]
x[c(1,3,5,7)]
2.3.3
Opérations
Les opérations sur les vecteurs s’effectuent élément par élément :
>
>
>
>
x<-1:5
y<-3:7
x+y
x*y
On peut aussi appliquer des opérateurs booléens ==, !=, >, >=, etc. Par exemple :
> x>3
> x[x<=3]
2.4
2.4.1
Matrices
Création
La principale méthode pour créer une matrice est d’utiliser la fonction matrix qui prend en arguments les coefficients de la matrice ainsi que son nombre de lignes (ou de colonnes) :
>
>
>
>
m <- matrix(1:6,ncol=2)
m
m <- matrix(1:8,nrow=2)
m
Par défaut, R range les valeurs par colonne. Pour ranger par ligne, on utilise l’argument byrow :
> m <- matrix(1:8,nrow=2,byrow=T)
> m
2
2.4.2
Extraction
L’emplacement d’un élément dans une matrice est donné par ses indices de ligne et de colonne :
> m[1,3]
Il est rare qu’on ait besoin de ne sélectionner qu’un élément d’une matrice. Usuellement, on
sélectionne une ou plusieurs lignes et/ou une ou plusieurs colonnes. Exemples :
— Sélection par des entiers positifs :
> m[2,]
— Sélection par des entiers négatifs :
> m[-1,]
> m[1:2,-1]
2.4.3
>
>
>
>
>
Opérations
m <- matrix(1:4,ncol=2)
n <- matrix(3:6,ncol=2,byrow=T)
m+n
m*n
m%*%n
Exemples de fonctions classiques en algèbre linéaire :
> det(m)
> solve(m)
> eigen(m)
2.5
Les listes
Les listes permettent de regrouper différents objets. Elles permettent, par exemple, de stocker dans
un même objet un vecteur et une matrice :
>
>
>
>
vec<-c(1,2,3)
mat<-matrix(1,ncol=2,nrow=3)
L<-list(vec,mat)
L
L’objet L ainsi créé est une liste de longueur 2. Le premier élément est le vecteur vec, le second la
matrice mat. On extrait les éléments d’une liste à l’aide de doubles crochets :
> L[[1]]
Il est également possible, et souvent utile, de donner des noms aux différents éléments d’une liste.
Ceci peut se faire grâce à la fonction names :
> names(L)<-c("vecteur","matrice")
> L
Dans ce cas, l’extraction peut toujours se faire via les doubles crochets ou bien à partir des noms
des différentes composantes, le symbole $ séparant le nom de la liste du nom de la composante :
> L$vecteur
3
De nombreuses fonctions de R renvoient un résultat sous la forme d’une liste, c’est le cas par exemple
de la fonction eigen vue ci-dessus, dont on liste les éléments via la fonction ls. Exemple :
>
>
>
>
>
m <-matrix(1:4,ncol=2)
dec<-eigen(m)
ls(dec)
dec$values
dec$vectors
2.6
Data-frames
Les data-frames sont les objets typiques pour faire des statistiques sous R. Ce sont des listes
particulières dont les composantes sont de même longueur, mais de types éventuellement différents.
Les tableaux de données utilisés en statistique, de forme (individus,variables), doivent être mis sous
la forme d’un data-frame. En effet, un tableau de données est constitué de variables quantitatives
et/ou qualitatives mesurées sur les mêmes individus. Les data-frames permettent de tenir compte
de la nature de chaque variable. Considérons un jeu de données de 6 individus et deux variables :
>
>
>
>
age<-c(17,28,64,8,25,36)
sexe<-c("H","F","F","H","H","F")
donnees<-data.frame(age,sexe)
donnees
L’extraction d’éléments peut se faire :
— comme pour une matrice :
> donnees[3,1]
> donnees[4,]
> donnees[,2]
— comme pour une liste :
> donnees[[2]]
> donnees$sexe
La fonction names permet de retrouver les noms des variables, ce qui peut être utile lorsque le
tableau de données contient beaucoup de variables :
> names(donnees)
3
3.1
Programmer en R
Les boucles (for ou while)
De manière générale, la boucle for s’écrit :
> for (i in vecteur) {
+
expr1
+
expr2
+
...
+ }
Une autre possibilité de boucle est la condition while. Sa syntaxe générale est la suivante :
4
> while (condition) {
+
expr1
+
expr2
+
...
+ }
3.2
Les conditions (if, else)
Sous sa forme générale, la condition if, else s’écrit :
> if (condition) {
+
expr1
+
expr2
+
...
+ } else {
+
expr3
+
expr4
+
...
+ }
Attention, l’ordre else doit être sur la même ligne que l’accolade fermante ”}” de la clause if.
3.3
Les fonctions
Une fonction permet d’effectuer un certain nombre d’instructions R, qui dépendent généralement
d’arguments spécifiés en entrée. La fonction fournit un résultat unique, qui est désigné à l’intérieur
de la fonction par return. En l’absence de cette instruction, la fonction renvoit comme résultat le
dernier résultat obtenu dans celle-ci. Donnons un exemple simple, à savoir la somme des n premiers
entiers. Le nombre n est un entier qui est l’argument d’entrée, le résultat est simplement la somme
demandée :
somme <- function(n) {return(sum(1:n))}
La fonction est ensuite appelée grâce à son nom (ici, somme), suivi du (ou des) argument(s) en
entrée entre parenthèses. Ainsi :
> somme(3)
4
Exercices
On utilisera R Markdown pour répondre à ces exercices et les sauvegarder dans un fichier que l’on
intitulera par exemple “Fiche1”.
4.1
Sélection et tri dans un data-frame
Le data-frame iris est disponible sous R. Il suffit de taper data(iris) pour le charger.
1. Obtenir un résumé de ce jeu de données grâce à la fonction summary. Quelles sont ses
dimensions ?
2. Retrouver les dimensions de ce jeu de données grâce à la fonction dim.
5
3. Visualiser ses cinq premières lignes.
4. Créer un nouveau data-frame, que vous appellerez iris2, comportant uniquement les données
de la modalité versicolor de la variable Species.
5. Trier par ordre croissant les données de iris2 en fonction de la variable Petal.Length (vous
pourrez utiliser la fonction order). Stocker le résultat dans un data-frame iris3. Vérifier le
résultat sur les premières lignes de ce nouveau data-frame grâce à la fonction head.
4.2
Retrouver un nombre mystère
On étudie le nombre de tirages au hasard nécessaires pour retrouver un nombre fixé entre 1 et n.
1. Choisir un entier entre 0 et n = 10, le stocker sous le nom myst. Ensuite, créer une boucle
qui, à chaque itération, tire un entier au hasard entre 0 et n = 10 jusqu’à obtenir myst (on
pourra utiliser la fonction sample dont on consultera l’aide). En sortie de boucle, le nombre
de tirages effectués sera renvoyé.
2. A partir de la question précédente, créer une fonction prenant en entrée les entiers n et myst,
et donnant en sortie le nombre de tirages nécessaires pour retrouver myst.
3. Pour n = 10 et le même myst qu’en première question, appliquer cette fonction M = 100
fois et stocker le résultat dans un vecteur res. Donner la moyenne de res et son écart-type.
Quels sont les résultats attendus théoriquement ?
4.3
La conjecture de Syracuse
L’algorithme de Syracuse, ou algorithme 3x+1, fonctionne comme suit : à partir d’un entier naturel
n ∈ N? , si n est pair on le divise par deux, si n est impair on le multiplie par 3 et on ajoute 1. On
répète ensuite l’opération avec le nombre obtenu, la conjecture étant qu’on finit par atteindre 1 et
boucler indéfiniment : en effet, à partir de ce nombre, on tombe sur le cycle 1,4,2.
1. Créer une fonction syracuse prenant un entier n en entrée, générant cette suite de Syracuse
et s’arrêtant lorsque l’on atteint 1. La fonction renverra en sortie la suite des nombres
obtenus. Indication : on pourra utiliser la fonction cbind pour concaténer la suite obtenue
au fur et à mesure de l’algorithme.
2. Grâce à une boucle, appliquer cette fonction à tous les entiers de 1 à 100 et stocker dans un
vecteur les 100 longueurs des suites associées (on ne demande pas de stocker les 100 suites).
A l’aide de la fonction plot, représenter sur un graphique les 100 longueurs.
3. Parmi les 100 suites créées, quelle est la longueur maximale atteinte ? Pour quel entier est-elle
atteinte ? Pour celui-ci, représenter la suite de Syracuse associée.
6