PRISE EN MAIN DU LOGICIEL R
GENEVIÈVE KURTH -- JOÊL KIEFFER
I ) GÉNÉRALITÉS ... 4
II) LES VECTEURS ... 7
1) Créer des vecteurs ... 7
2) Quelques fonctions agissant sur les vecteurs: ... 9
3) On peut jouer sur les indices ... 9
III) SIMULATIONS :LES LOIS DE PROBABILITÉ ... 11
1) La loi binomiale ... 11
2)la loi hypergeometrique ... 13
3) La loi exponentielle... 16 4) La loi géométrique ... 19 5) Autres lois... 20 a) Loi uniforme... 20 b) Loi normale... 20 c) Loi de poisson... 21 6) La fonction sample ... 23
IV) LES GRAPHIQUES ... 24
1) Généralités... 24
2) Les fonctions graphiques de 1er niveau: ... 27
plot... 27
curve... 28
histogramme ... 29
barplot... 29
diagrammes en bâton ou histogramme ? ... 30
Boxplot... 31
Pie ... 32
3) Fonction graphique de second niveau... 33
abline ... 33
lines ... 33
rectangles ... 34
4) les fonctions graphiques du package Simple... 36
V) LES FONCTIONS (OU PROGRAMMES)... 38
VI) LES TABLEAUX DE DONNÉES ... 39
1) Utiliser un tableau déjà enregistré ... 39
2) fabriquer son propre tableau : ... 42
3) la fonction tapply ... 45
4) des fonctions de tri... 46
VII) LES COULEURS ... 46
VIII) ENFIN DES SIMULATIONS ... 48
simulation1 ... 48
simulation 2 ( suite de la précédente ) ... 49
simulation 3 ... 50 Simulation 4... 51 simulation 5 ... 52 Simulation 6... 53 simulation 7 ... 53 simulation 8 ... 55 simulation 9 ... 55 simulation 10 ... 57 Simulation 11... 57 Simulation 12... 58
IX) QUELQUES ACTIVITÉS ( TRAITEMENT DES DONNÉES )... 59
tirées de manuels de lycée section ES ou L ... 59
1) Un test d'adéquation à une loi équirepartie ... 59
2) Activité 2... 60
X) ET LA RÉGRESSION LINÉAIRE ? ... 67
XI) INCURSIONS DANS D'AUTRES DOMAINES ... 71
1)Les surfaces en couleur ... 71
2) Les suites numériques ... 74
3) un peu d'arithmétique ... 76
4) un peu de géométrie... 78
a) Tracer un polygone étoilé régulier (n,m)... 78
b) le flocon de Von Koch... 79
5)un peu d'algèbre linéaire... 81
XII) PROGRAMMER AVEC R... 83
XIII) LA GESTION DES FICHIERS ... 83
I ) Généralités
J'ai entrepris d'écrire ce document pour faire découvrir à mes collègues les potentialités de R en matière de simulations .
En chemin, nous avons découvert que c'est un outil bien pratique en matière de statistique descriptive .
Puis que ce logiciel pouvait être utile en toutes sortes de domaines ( études de suites, arithmétique , surfaces etc ), grâce à son langage de programmation très souple . Ce document traite donc de différents sujets de niveau lycée
et de simulation probabiliste (à des niveaux variés ).
Il a pris , au fil des ajouts, un aspect un peu touffu, mais il me semble que c'est bien ainsi. Mon objectif est d'offrir une introduction informelle ( " friendly " dirait on en anglais ) au langage de R, au niveau indiqué (*) .
Il est conçu pour être pratiqué sur la console R , ( "read and play" ) plutôt que pour être lu comme une introduction systématique . Donc "essayez et voyez " .
nb : toutes les instructions en langage R , sont précédées du "prompt" > et sont en caractère "courrier new" ;
vous pouvez les copier-coller directement du document sur la console .
( mais ne copiez pas le ">" , qui étant doublé générerait un message d'erreur ). Tout le reste consiste en commentaire .
Si vous faites précéder chaque ligne de commentaire d'un # ,et que vous effacez les" >" , vous pouvez alors copier-coller des portions plus importantes de ce document .
(*) R est avant tout un logiciel de statistique , au niveau universitaire .
Il est utilisé par des spécialistes en biologie , économie , dynamique des populations, santé publique , etc ,etc
Il est donc vu ici par un tout petit bout de la lorgnette !
Pour ceux qui souhaitent une introduction à l'utilisation de R en statistique, on trouve énormément de choses sur internet.
Par exemple sur le site miroir de R à Toulouse
http://cran.cict.fr/ choisissez " Contributed " et vous obtenez une bibliographie conséquente(**)
vous pouvez télécharger R en choisissant Download (windows95 and later)
puis base puis R-2.4.0-win32.exe
(**) Mais consultez d'abord John Verzani "Using R for introductory statistics " disponible également à l'adresse :
Venons en aux faits
R est sensible à la casse : a et A désignent 2 variables différentes ; i et I également , (alors que 1i désigne le nombre complexe i )
> 1i^2 [1] -1+0i
Le signe "=" est le symbole d'affectation (on écrit indifféremment a=3 ou a<–3)
Le signe égal est "= =" , il renvoie une valeur logique : vrai ou faux a=3
a==2 [1] FALSE
"<= "signifie inférieur ou égal etc .
round(x,n) donne une valeur approchée de x avec n décimales print(x,n) n'affiche que n chiffres de x
>pi [1] 3.141593 > print(pi,20) [1] 3.141592653589793 > p=round(pi,3);p [1] 3.142 > pi-p [1] -0.0004073464 > print(pi-p,20) [1] -0.00040734641020678808
On distingue les variables entières , numériques , de caractère ou logique .
>as.character(1) # le chiffre 1 sera considéré comme un caractère [1] "1"
> as.logical(1) # 1 prends une valeur logique [1] TRUE
"&" et " |" sont les symboles logiques "et " et "ou" . "!" est le symbole de la négation ;
donc " a!= = 2" signifie "a différent de 2" .
Si une ligne est incomplète au moment où vous faites "entrée" , R passe à la ligne suivante et affiche + : à vous de compléter. Si vous ne savez pas comment, on entre dans un cercle vicieux ! Faites "Echap" pour en sortir.
Dans le menu "edit" , "clear console" permet de vider l'écran, mais les objets qui ont été créés restent disponibles.
Dans le menu "Misc", "List objects" permet de savoir quels sont les objets disponibles. >objects() # a le même effet ainsi que ls()
Dans le même menu , "remove all objects" , supprime tous les objets. Pour supprimer un objet particulier
>rm (nom de l'objet)
On obtient de l'aide sur une fonction en écrivant son nom précédé de ?
une liste très complète des fonctions disponibles dans l'index du manuel de référence (1119 pages dont plus de 20 d'index !)
Ou mieux encore : activer dans le menu help , Rlanguage (html) ,puis package , puis base
on obtient alors un index alphabétique des fonctions disponibles .
Pour progresser dans la compréhension des diverses fonctions , il ne faut pas hésiter à faire des copier-coller à partir des exemples de l'aide :
on sélectionne le texte , puis un clic droit permet de coller directement le texte sur la console . A ce propos , tout texte précédé de # est considéré comme un commentaire .
Essayer aussi "searchengine & keyword ".
table
II) Les vecteurs
C'est l'objet de base ; en fait c'est une liste indicée.
1) Créer des vecteurs
Si on veut entrer des données particulières , le plus simple est d'écrire a = scan() et d'écrire à la suite les valeurs ,
en appuyant sur entrée entre chaque valeur .
Sinon il y a des moyens automatiques :
>1:10 [1] 1 2 3 4 5 6 7 8 9 10 > 1/(1:10) [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000 0.1666667 0.1428571 [8] 0.1250000 0.1111111 0.1000000 > a=6*runif(10)+1 > a [1] 5.722479 6.997719 3.048673 6.484689 6.168810 1.192138 6.833995 5.420272 [9] 6.792978 3.498775 > b=as.integer(a) > b [1] 5 6 3 6 6 1 6 5 6 3
> b[2] # le second terme de la suite [1] 6
> b<6 # renvoie un vecteur logique
[1] TRUE FALSE TRUE FALSE FALSE TRUE FALSE TRUE FALSE TRUE >as.numeric(b)
[1] 1 0 1 0 0 1 0 1 0 1 > sum(b<6)
[1] 5
runif(10) donne 10 nombres aléatoires suivant la loi uniforme sur [0,1] Dans b on ne retient que la partie entière
on aurait aussi pu écrire
b= floor(a) (floor = plancher) ( de même ceiling = plafond)
> a= rnorm(1000)
donnera un tirage aléatoire de 1000 nombres suivant la loi normale μ = 1 et σ = 1 Combien de ces nombres sont supérieurs à 2 ?
> sum(a<2) #nous le dira
En fait a < 2 est un vecteur logique qui est interprété numériquement par la fonction sum
Un autre moyen de créer des listes est l'opérateur de concaténation > x=c(2,7,5,12) #crée un liste de 4 nombres
Il existe également une fonction séquence
> seq(10,30) # par defaut le pas est de 1
[1] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
> seq(10,30,2) # 2 indique le pas
[1] 10 12 14 16 18 20 22 24 26 28 30 > seq(1,3,0.1) # pas de 0.1
[1] 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8
[20] 2.9 3.0
> seq(1,50,length=8) # une autre manière de découper [1] 1 8 15 22 29 36 43 50
La fonction de répétition est pratique
> c(rep(2,8),rep("a",5))
[1] "2" "2" "2" "2" "2" "2" "2" "2" "a" "a" "a" "a" "a" > c(rep(2,8),rep(a,5)) [1] 2 2 2 2 2 2 2 2 2 2 7 3 6 7 9 8 2 2 2 1 9 6 4 2 7 4 5 8 2 2 7 3 6 7 9 8 2 [38] 2 2 1 9 6 4 2 7 4 5 8 2 2 7 3 6 7 9 8 2 2 2 1 9 6 4 2 7 4 5 8 2 2 7 3 6 7 [75] 9 8 2 2 2 1 9 6 4 2 7 4 5 8 2 2 7 3 6 7 9 8 2 2 2 1 9 6 4 2 7 4 5 8
Observez que dans le premier cas c'est la lettre "a" qui est répétée 5 fois ; les éléments du vecteur prennent alors tous le statut de caractère .
(tous les éléments d'un vecteur doivent avoir le même statut ;
c'est la différence avec les listes qui peuvent grouper des termes de statut différents) Dans le second cas , c'est la liste a, précédemment crée, qui se trouve répétée !
La fonction gl offre d'autres possibilités : tapez > ?gl
Il existe des listes toutes prêtes.
> LETTERS[7:12]
[1] "G" "H" "I" "J" "K" "L"
> letters[13:18]
[1] "m" "n" "o" "p" "q" "r"
2) Quelques fonctions agissant sur les vecteurs:
à essayer !max , min , range , sum , length cumsum , cummax et cummin , sort , diff
mean , sd ( standard deviation = écart type ) fivenum , summary et IQR (Inter Quartile Range)
La fonction table est très pratique # résultat du lancer de 10000 dés > a = ceiling(6*runif(10000)) > table(a) a 1 2 3 4 5 6 1648 1635 1674 1728 1666 1649
On calcule avec les vecteurs comme avec des nombres : (ou bien comme avec des listes sur un calculatrice TI 83 ) >z=1:10 ; z+100 ; z+z ; 2*z ; z*z ; z^3
> y= (xx^2+5)/10 donne un nouvelle liste de 9 nombres Le 7ieme nombre est y[7] = 5.4
table
3) On peut jouer sur les indices
> a=ceiling(9*runif(20)) > a[1] 2 2 7 3 6 7 9 8 2 2 2 1 9 6 4 2 7 4 5 8 > a[a<7] # nouveau vecteur ne comportant que les termes < 7 [1] 2 2 3 6 2 2 2 1 6 4 2 4 5
> a[a<7&a>2] # rappel "&" signifie "et" [1] 3 6 6 4 4 5
> a[a>7|a<2] # "|" signifie "ou" [1] 9 8 1 9 8
> a[5:15]
[1] 6 7 9 8 2 2 2 1 9 6 4 # ne retient que les indices de 5 à 15 > a[-5:15]
[1] 2 2 7 3 7 4 5 8 # exclut les indices de 5 à 15
La fonction suivante, which , renvoie des indices; on peut trier b suivant un critère issu de a. > which(a==2)
[1] 1 2 9 10 11 16 > which(a==3)
[1] 4 # 3 arrive en 4ème position dans la liste a > which(a==10)
numeric(0) # c'est à dire aucun > which(a==max(a))
[1] 7 13 >a=ceiling(9*runif(20)); b=ceiling(9*runif(20)) > a;b [1] 7 8 6 6 3 4 6 8 6 1 8 3 1 1 5 8 7 9 1 4 [1] 4 5 3 1 2 2 5 7 2 7 2 3 3 7 9 8 9 6 2 4 > b[which(a==8)] [1] 5 7 2 8
# on ne retient que les valeurs pour lesquelles a = 8
# Ranger un vecteur x dans l'ordre croissant suppose d'effectuer une permutation Cette permutation est donnée par la fonction order
> x=c(13,18,15,12,19,11,14,16,17) > o=order(x);o
[1] 6 4 1 7 3 8 9 2 5 # 11 est le 6ème , 12 le 4ème , etc
Si y est un vecteur de même longueur que x , on peut alors ordonner y suivant les valeurs croissantes de x >y=c(21,22,23,24,25,26,27,28,29) >y[o] [1] 26 24 21 27 23 28 29 22 25 Comparons > x;y [1] 13 18 15 12 19 11 14 16 17 [1] 21 22 23 24 25 26 27 28 29 alors que >x[o];y[o] [1] 11 12 13 14 15 16 17 18 19 [1] 26 24 21 27 23 28 29 22 25
En résumé , si on veut ordonner y suivant les valeurs croissantes de x , et comparer les valeurs , il suffit d'écrire :
>o=order(x);x[o];y[o]
si on veut ranger y et z , on écrira >o=order(x);x[o];y[o];z[o]
III) Simulations :les lois de probabilité
On peut simuler un grand nombre de lois de probabilités Le nom de chaque loi est précédé de r comme random On a déjà vu runif
> round(rnorm(10,5,2),3) # round fixe le nombre de décimales
[1] 5.441 2.330 3.910 3.790 8.000 2.624 5.226 2.175 7.266 4.280 > rpois(10,5) [1] 5 6 1 3 6 5 6 4 1 2 > rgeom(10,0.1) [1] 12 41 3 1 7 8 8 10 1 12 > rbinom(10,10,0.4) [1] 7 4 5 4 2 2 4 5 4 6
Successivement , la loi normale de moyenne 5 et ecart type 2 ( arrondi à 3 chiffres )
la loi de poisson de paramètre 5 la loi geometrique de paramètre 0.1
la loi binomiale de taille 10 et probabilité de succès = 0.4 détaillons :
1) La loi binomiale
# X suit la loi B(10,0.6)>dbinom(4,10,0.6) # donne P(X = 4) # pour obtenir les densités de probabilités P(X=k) >dx=dbinom(0:10,10,0.6);dx
>sum(dbinom(4:8,10,0.6) # donne P(4≤ X ≤ 8) # un diagramme en bâton
>barplot(dx) #un autre tracé >plot(dx) # le même amélioré
# Pour obtenir la fonction de répartition P(X≤ k) >px=pbinom(0:10,10,0.6);px
>plot(px,type='h',col="red",lwd=8)
# un tirage de 100 valeurs de X >x=rbinom(100,10,0.6);x # pour analyser rapidement les résultats >t=table(x);t;barplot(t)
# autre moyen d'analyser les résultats :
#on va découper le vecteur par intervalles et faire un histogramme
>brk=-0.5:10.5 # le découpage >hist(x,breaks=brk)
>hist(x,breaks=brk, col="yellow",label=T) # amélioré
# On souhaite aussi comparer avec les effectifs théoriques >points(0:10,100*dx)
>points(0:10,100*dx,type='h',col="red",lwd=2) # amélioré
plot(pbinom(0:20,20,0.4),col="green",lwd=10,type="h")
table
2)la loi hypergeometrique
une urne contient 15 boules , 5 blanches et 10 noires ;
on tire 4 boules sans remise ; combien de boules blanche obtient on ?
> rhyper(1,5,10,4)
[1] 2 # 2 boules sur 4 sont blanches
h=rhyper(20,5,10,4);h # on effectue 20 tirages [1] 1 1 2 2 3 2 2 2 2 1 3 1 2 1 1 0 1 1 2 0 > h=rhyper(10000,5,10,4) # on effectue 10000 tirages # éviter ";h" si vous ne voulez pas voir apparaître les 10000 résultats ! > t=table(h) > t h 0 1 2 3 4 1539 4374 3298 763 26 > barplot(t)
0 1 2 3 4 0 100 0 2000 3 000 40 00
Pas mal non ? mais peut mieux faire
v=rhyper(200,5,10,4)
br=-0.5;4.5 # impose un découpage pour l'histogramme h=hist(v,breaks=br,label=T,col="green") # label = T permet l'affichage des effectifs sur l'histogramme
t=h$counts # permet de récupérer les effectifs t= t/200 # donne les fréquences
plot(dh,t,pch=25);abline(0,1) 0.0 0.1 0.2 0.3 0.4 0 .00 .1 0 .20 .30 .4 dh t Explication :
dhyper donne les probabilités d'obtenir de 0 à 4 boules blanches On compare avec les fréquences obtenues sur 200 essais.
plot(dh,t) trace les points, ( pch= 25 : ils sont en forme de triangle ) abline(0,1) ajoute la droite ax+b , a =1 ,b=0
> m=rbind(dh,t) > barplot(m,beside=TRUE) 0 1 2 3 4 0. 0 0. 1 0. 2 0. 3 0 .4
rbind assemble les vecteurs dh et t
en une matrice à 2 lignes (r =row , bind = assembler )
barplot produit
n diagramme en bâton de dh et de t côte à côte ( beside = à côté ) u
NB : à propos de la fonction "table "
Le lecteur averti se demandera , pourquoi avoir utilisé h$counts pour obtenir les effectifs ? N'eut t'il pas été plus simple d'employer la fonction table ?
En effet !
Mais ici , sur 200 essais , il y a de forte chance que le résultat 4 ( 4 boules blanches ) n'apparaisse pas.
En posant t = table(v) , on obtient alors un vecteur de longueur 4 , alors que dh est un vecteur de longueur 5.
plot(dh,t) entraînerait alors un message d'erreur.
C'est une difficulté de la fonction table ( voir plus loin la loi géométrique ).
table
3) La loi exponentielle
Elle peut être simulée par rexp(100, 0.5) , ici λ = 0.5 C’est une loi continue cette fois.
X suit la loi exponentielle de paramètre 0.5 ( par défaut , ce paramètre vaut 1 ) donc l'espérance de X est 2 , ainsi que l'écart type .
# un échantillon de 1000 valeurs de X >a=rexp(1000,0.5)
# on ne souhaite pas vraiment voir le détail !
# voici dans l'ordre la moyenne , l'écart type , le maximum de l'échantillon . >mean(a);sd(a);max(a)
# la moyenne plus 4 écart type , cela fait 10 ;
# y a t'il des valeurs au delà de 10 , et lesquelles ? quel est leur ordre d'arrivée ?
>a[a>10] ; which(a>10)
#analyse graphique :
# ici , la fonction table n'est pas pertinente , puisque toutes les valeurs de X sont différentes # on va d'abord découper x en intervalles
>brk=0:ceiling(max(a)) >acut=cut(a,brk)
>barplot(t)
# ou bien
>hist(a,breaks=brk,ylim=c(0,500),col="yellow") >curve(1000*dexp(x,0.5),add=T,col="red",lwd=2)
#explication :
#dexp(x , 0.5) est la fonction de densité de la loi X
# La seconde instruction vient donc superposer (add=true) la densité théorique à l'histogramme des densités observées
# On voit ici quelques paramètres supplémentaires dans les graphiques : ylim = c(0,500) impose l 'intervalle sur Oy
lwd = 2 contrôle l'epaisseur du tracé ( lwd = line width )
#de même pexp(x,0.5) donne la fonction de répartition de la loi X
>curve(pexp(x,0.5))
# il est intéressant de connaître les quantiles de la loi # par exemple les déciles
>dec=(0:10)/10;dec
>dec=seq(0,1,0.1);dec # donne la même chose >qexp(dec,0.5)
# quel est le 95ème centile en théorie ? q(0.95,0.5)
# et dans l'échantillon ? oa=sort(a);oa[950]
4) La loi géométrique
X suit la loi géométrique de paramètre p
X indique le temps d'attente du premier succès , sachant que la probabilité d'un succès est p . X=0 signifie succès au premier coup , X=1 signifie succès au 2ème coup , etc
>pgeom (0:20,0.1) # donne les probabilités cumulées # on observe que P (X ≤ 20 ) est strictement inférieure à 1 Voici les déciles de la loi
> qgeom(seq(0,1,0.1),0.1)
[1] 0 0 2 3 4 6 8 11 15 21 Inf
Comparons la fonction barplot appliquée à la table , avec un histogramme >g=rgeom(100,0.1) >t=table(g);t >br=-0.5:(max(g)+0.5) >layout(c(2,1)) >hist(g,breaks=br,col=3);barplot(t) table
5) Autres lois
D'une manière généralele nom de la loi précède de la lettre d donne la fonction de distribution de la loi P(X = k) ; le nom de la loi précède de la lettre p donne la fonction de répartition de la loi P(X ≤ x) ; le nom de la loi précède de la lettre r donne une simulation ;
le nom de la loi précède de la lettre q donne les quantiles .
a) Loi uniforme
>runif(1) # donne un nombre aléatoire entre 0 et 1 ( valeurs par défaut ) >runif(1,2,9) # donne un nombre aléatoire entre 2 et 9
>runif(100) # donne 100 nombres aléatoires entre 0 et 1 ( valeurs par défaut ) >runif(100 , 2,9 ) # donne 100 nombres aléatoires entre 2 et 9
Il s'agit d' une loi continue ; on peut la discrétiser de diverses manières > a= runif(20,1,7)
> as.integer ( a ) > ceiling(a)
> floor(a)+1
b) Loi normale
> rnorm(20) # par défaut μ = 0 et σ = 1 > rnorm(20,10,5) # ici μ = 10 et σ = 5
>pnorm(9,5,2) # donne P(X≥9) , X suivant N(5,2) >qnorm(0.9,5,2) # donne le 9ème décile de cette loi
>dec=seq(0,1,0.1); qnorm(dec,5,2) # donne les déciles >x=rnorm(1000)
>fivenum(x)
# donne min , 1er quartile , médiane , 3ème quartile et max >IQR(x) # donne l'écart interquartile
>summary(x) >boxplot(x)
layout(c(2,1)
curve(pnorm(x,5,2),xlim=c(0,10))
# m= moyenne , s= écart type
#pnorm(x,m,s) donne la probabilité p = P(X<=x) #qnorm(p,m,s) donne x tel que P(X<=x) = p
Grâce à ces fonctions , on peut définir de nouvelles fonctions :
pr =function (a,b,m,s) pnorm(b,m,s)-pnorm(a,m,s) # donne p=P(a<x<b)
prc=function(d,m,s) pnorm(m+d,m,s) -pnorm(m-d,m,s) # donne p= P(m-d<x<m+d)
écart=function(p,m,s) qnorm((p+1)/2,m,s)-m # donne d tel que P(m-d<x<m+d) = p
c) Loi de poisson
>a= rpois(10000,5) # 10000 tirages suivant la loi de poisson de paramètre 5 # l 'espérance est 5 et la variance aussi
> mean(a);sd(a);var(a)
> plot(0:15,d,type="h",lwd=3,col=4)
Pour obtenir une table de valeurs plus lisible > d=round(dpois(0:15,5),4) > m=c(0:15,d);dim(m)=c(16,2);m [,1] [,2] [1,] 0 0.0067 [2,] 1 0.0337 [3,] 2 0.0842 [4,] 3 0.1404 [5,] 4 0.1755 [6,] 5 0.1755 [7,] 6 0.1462 [8,] 7 0.1044 [9,] 8 0.0653 [10,] 9 0.0363 [11,] 10 0.0181 [12,] 11 0.0082 [13,] 12 0.0034 [14,] 13 0.0013 [15,] 14 0.0005 [16,] 15 0.0002 Commentaire :
on ne retient que les arrondis à 10–4
puis on groupe les valeurs de k et de P(X=k) en une liste , que l'on dimensionne en 16 lignes et 2 colonnes .
6) La fonction sample
sert à réaliser des tirages>sample(10) # ou sample(1:10) >sample(10:20)
>sample(10:20,3)
# si x est un vecteur , sample(x) renvoie une permutation de x
# sample(x , n ) renvoie un arrangement de n termes pris dans x ( sans remise ) # ceci nécessite donc que n ≤ length(x)
#si on veut effectuer un tirage avec remise , il n'y a plus de contrainte sur n
>x= letters[1:5] ; length(x) >sample(x,20,replace=T)
>sample(x,20,T) # la même chose
# dans les cas précédents ,
# s'il y a remise , chaque élément de x est choisi avec équiprobabilité # sans remise , il y a équiprobabilité entre les éléments restants # c'est la règle par défaut ; elle peut être modifiée
>x= c(0,1)
>s=sample(x,100,T) ;s; sum(s) # équiprobabilité >s=sample(x,100,T,prob=c(1,2)) ;s;sum(s)
# cette fois le choix de 0 ou de 1 a une probabilité proportionnelle à 1 et 2 >table(x)
Une petite partie de cartes ?
>cartes=paste(gl(8,4,
label=c(7:10,"valet","dame","roi","as")),
c("de cœur","de pique","de carreau","de trèfle")) >sample(cartes,5) # une main au poker
[1] "as de cœur" "7 de carreau" "roi de pique" "9 de cœur" "10 de pique"
Pour comprendre comment est fabriqué le jeu : tapez > ?gl
Vous préférez les dés ?
on lance 5 fois une paire de dés , ferez vous un "double as " ? > dés= outer(1:6,1:6,paste)
> sample(dés ,5,replace=T)
[1] "2 2" "4 6" "6 3" "3 4" "3 6" C'est raté !
Pour la fonction outer voir plus loin le chapitre " surfaces "
IV) Les graphiques
R distingue des tracés de premier niveau et de second niveau .
Les second peuvent être ajoutés à un graphique de premier niveau en activité .
1) Généralités
Par défaut un fenêtre graphique s'ouvre seulement quand on demande un tracé Le tracé suivant efface le précédent .
Si on veut éviter cela , on peut utiliser > windows()
qui ouvre une nouvelle fenêtre et désactive la précédente (mais ne l'efface pas). Les fenêtres sont numérotées à partir de 2 ;
donc la fenêtre active est maintenant la 3 .
Pour réactiver la 2 , si on veut par exemple l'améliorer et la compléter : > dev.set(2) # dev pour devices = outil , set =installer
Consulter le menu windows sur la barre d'outils pour voir les fenêtres actives
Il y a de nombreuses possibilités de combiner plusieurs graphiques dans une même fenêtre .
On a déjà vu layout
> layout(matrix(1:4,2,2))
Partage l'écran en 4 parties égales numerotées de 1 à 4 , et rangées en 2 lignes et 2 colonnes . Par defaut lignes et colonnes ont la même dimention
on numerote en suivant les colonnes mais > layout(matrix(1:4,2,2,byrow=T)) permet de numeroter en commençant par les lignes
>layout(matrix(1:4,2,2,byrow=T),c(1,2),c(3,1)) Ici encore 4 fenètres, numerotées suivant les lignes cette fois ,
la seconde colonne est 2 fois plus large que la première et la première ligne est 3 fois plus grande que la seconde
> a=runif(100);b=rnorm(100);c=rpois(100,5);d=rbinom(100,10,0.6) > layout(matrix(1:4,2,2));hist(a);hist(b); hist(c); hist(d)
layout(matrix(1:4,2,2),c(1,2));hist(a);hist(b);plot(a);plot(b)
la première colonne est plus étroite que la seconde les largeurs sont dans le rapport de 1 à 2
voir aussi ? split.screen qui offre de nombreuses possibilités . screen(1) , screen(2) , permettant d'appeler à volonté
la partie du graphique sur laquelle on souhaite travailler .
Pour plus de renseignements , consulter le document D' Emmanuel Paradis page 27 – 30 ainsi que les pages 30 à 33 pour des tableaux synthetiques sur les types de graphiques et leurs paramètres que nous allons voir maintenant :
2) Les fonctions graphiques de 1
erniveau:
plot > a=ceiling(6*runif(60)) > plot(a) > plot(a,type="l") > plot(a,type="l",main="60 dés") > plot(a,type="l",main="60 dés",col="red") > plot(a,type="h",main="60 dés",col="red") > plot(a,type="h",main="60 dés",col="red",lwd=3)> plot(a,type="h",main="60 dés",col="red",lwd=3,xlab="le nième lancer",ylab="est un")
> ?plot
ceci pour montrer comment on peut " travailler " un graphique .
Chaque fonction graphique peut être utilisée de manière "brute" , ou agrémentée de manière de plus en plus raffinée par de nombreux arguments .
(nb : ceci peut donner un aspect "barbare" à de nombreux exemples trouvés dans l'aide , mais a) la plupart des arguments peuvent être supprimés .
b) on peut copier-coller en l'état et supprimer progressivement les arguments pour voir l'effet obtenu )
type régit le type de tracé , lwd l'épaisseur , col la couleurs
Dans les exemples précédents ,ce sont les points (n,a[n] ) qui sont tracés ; plot(a) place donc les valeurs de a en ordonnée ;
en abscisse se trouvent les indices , commençant par 1 .
lors que plot(a,b) trace les points ( a[n] , b[n] ) a
exemple :
sur un axe , on avance ou on recule d'un pas suivant la loi de bernouilli de paramètre 0.6 on effectue 10 pas quel sont les points d'arrivée ainsi que leur probabilité
> a=dbinom(0:10,10,0.6) # donne les probas >b= seq(-10,10,2) # donne les points d'arrivée > layout(1:2) # pour comparer 2 tracés
> > plot(a,pch=17,xlab="")
> plot(b,a,pch=15,xaxt="n",axis(side=1,b), xlab="points d'arrivée")
nb : xaxt = "n" a pour effet que l'axe des x ne soit pas tracé axis(side=1 , b ) trace l'axe ses x en imposant la graduation b sinon , on obtient une graduation par défaut , ici , -10,-5,0,5,10 .
autre exemple :
> plot(sin ,-pi , pi) # trace une courbe > x=seq(0,4,0.1);plot(x,sqrt(x),type="l")
table curve
Cependant pour les tracés de fonction , curve est mieux adapté : > curve(exp(x)/x,-2,2)
> curve(5*x^2,add=T,col="red") > abline(h=0,col="green")
> abline(v=0,col="green")
>curve(dchisq(x,5),xlim=c(0,20)) # la densité de la loi du χ2 a 5 degrés de liberté
Curve est une fonction de 1er niveau, mais peut être utilisée au 2d niveau grâce à Add=TRUE abline est typiquement du 2d niveau
abline(b,a) ajoute y= ax +b au graphe en cours .
histogramme > a=rgeom(200,0.2) >hist(a) >hist(a,plot=F) >h=hist(a , breaks=-1:(max(a)+0.5),col="yellow") >h$counts # permet de récupérer les effectifs par classe
# un découpage plus pertinent
>hh=hist(a,breaks=c(0,1,2,3,5,10,20,50,100),col=3,labels=T) >hh$counts
La forme "brute" est simple , mais le découpage en classes est fait automatiquement ,. plot=FALSE , montre que l'objet "hist(a)" n'est pas un simple graphique
et permet de voir les dessous de l'affaire .
Ensuite une variante plus élaborée : breaks = vecteur sert à forcer le découpage ;
En vue du même but hist(a,20) demande qu'il y ait 20 classes , mais ne force pas le résultat . consulter ?hist . table barplot diagramme en bâton > a=rgeom(200,0.2) ; barplot(a) > barplot(table(a))
le premier n'est pas exactement ce que l'on attends !
logique : il faut que les données soient triées avant le tracé .
>a=c(1,1,4,7,5,2);b=c(2,1,2,6,5,4);c=c(2,2,8,6,1,1) >m=rbind(a,b,c) > mm=cbind(a,b,c) > layout(matrix(1:4,2,2)) > barplot(m) > barplot(mm) > barplot(m,beside=T) > barplot(mm,beside=T) produit le graphique suivant
05 1 0 1 5 a b c 05 1 0 1 5 2 0 024 68 a b c 02 4 68
les 3 séries de valeurs a , b et c sont groupées dans la matrice m à 3 lignes ( r= row) ou dans la matrice mm à 3 colonnes .
Des diagrammes en bâton sont tracés au 1er étage , comparant les séries terme à terme ; alors qu'au 2d étage , la comparaison se fait série à série .
table
diagrammes en bâton ou histogramme ?
#fabriquons un exemple sur mesure
> a=c(runif(10),1+4*runif(20),5+10*runif(30))
# a comprends donc 10 nombres entre 0 et 1 , 20 entre 1 et 5 et 30 entre 5 et 15 >brk=c(0,1,5,15)
>b=cut(a,brk)
cette instruction a pour effet de remplacer les valeurs de a par les intervalles définis par les valeurs de brk
>t=table(b)
> barplot(table(b))
windows() # permet d'ouvrir une seconde fenêtre hist(a,breaks=brk,col="green")
table Boxplot > a=rbinom(50,10,0.4) > boxplot(a) > b=rbinom(50,10,0.5);c=rbinom(50,10,0.6) > boxplot(a,b,c) > boxplot(a,b,c,notch=T) > d=rgeom(1000,0.1);boxplot(d,range=0) > boxplot(d,range=3) > boxplot(d,range=0.5)
notch = encoche , voir l'aide de boxplot .
si range= 0 , aucun terme n'est exclu , les moustaches vont du minimum au maximum ; par défaut range =1.5 : les moustaches s'étendent jusqu'à 1.5 fois l'écart interquartile ;
à ce propos ( voir aussi plus généralement "?quantile ") > fivenum(d)
[1] 0 2 6 12 60
on peut essayer ceci : > x=rnorm(200);boxplot(x,col="turquoise",border="blue") > abline(h=fivenum(x),col="red") ou ceci > layout(1:2) > hist(d, col="tomato") > boxplot(d,col="turquoise",border="blue",horizontal=T) table Pie
applepie , chickenpie , etc , tarte ou tourte
(to have a finger in the pie = avoir part au gâteau !) > pie(a)
>pie(table(a))
mêmes remarques que pour barplot
> a=rpois(20,5) > table(a) a 1 2 3 4 5 6 7 2 2 4 4 3 2 3 > pie(table(a),col=rainbow(10)) table
3) Fonction graphique de second niveau
Elle viennent s'ajouter à un graphique déjà existant , obtenu grâce à des fonctions de premier niveau
abline
déjà vu , cependant :
> plot(c(-2,0,2),c(0,4,0),type="n")
>for (j in -20:20){a=j/10; abline(-a^2,2*a)}
plot trace 3 points (-2,0) , (0,4) , (2,0) , mais grâce à type="n" la tracé n'est pas apparent on obtient seulement le cadre voulu , vierge
sur lequel on peut tracer des graphiques de second niveau :
les droites y = 2ax – a2 , c'est à dire une famille de tangentes à une parabole
lines
interpolation linéaire :
a=c(1950,1960,1970,1975,1982,1986,1992,1999,2004) b=c(112,123,145,132,129,140,157,181,178)
plot(a,b,col=2);lines(a,b,col=3) rectangles > x=seq(0,0.9,0.1); xx=x+0.1 > y=x^2;yy=xx^2 > plot(0:1,0:1,type="n") > rect(x,0,xx,y,col="turquoise") > rect(x,y,xx,yy,col="yellow") > curve(x^2,0,1,col="red",lwd=2,add=T)
La 3ème ligne est une astuce :
comme rect est une fonction de 2d niveau , elle ne peut être qu'ajoutée à un graphique existant type= "n" , signifie qu'un graphique est lancé , mais les points ne sont pas tracés : n =nul; autre intérêt : 0:1,0:1 définit le cadre du tracé ..
0.0 0.2 0.4 0.6 0.8 1.0 0 .00 .20 .4 0 .60 .81 .0 0:1 0: 1 Points > curve(x^2,0,1,col=4) > p=(1:9)/10;q=p^2+rnorm(9,0,0.02) > points(p,q,col=2)
la 3ème ligne est à rappeler plusieurs fois ; on peut aussi combiner avec lines(p,q)
segments
> segments ( a,b,c,d)
ajoute le segment joignant les points (a,b) et (c,d) au graphique courant
essayez rug (paillasson ) >a=rexp(200) >hist(a);rug(a)
b=rgeom(200,0.2)
hist(b);rug(jitter(b))
comme la loi géométrique est discrète jitter permet d'obtenir un "tremblement " sur les valeurs de b ( comparez b à jitter(b) )
voir aussi stripchart et dotchart
et legend , title , axis , text pour agrémenter les tracés ; ainsi que ? par pour une foule de paramètres .
Par exemple pch = (point character) contrôle la forme des points , à ce propos essayez
lty (line type) le type de traits , lwd (line width ) l'épaisseur des traits
la suite en dit plus qu'un long discours : >plot(1:6,1:6,type="n")
> abline(h=1:6,col=2:7,lwd=1:6,lty=1:6)
avec la fonction text , un exemple pour rire
> plot(1:10,1:10,type="n");text(1:9,1:9,cex=1:9,col=2:4)
table
4) les fonctions graphiques du package Simple
>a=rpois(1000,5)>simple.violinplot(a,col="turquoise")
> b = 10*runif(1000)
> simple.scatterplot(a,b)
V) Les fonctions (ou programmes)
Une fonction désigne plutôt ,dans ce contexte ,un programme ,
les arguments de la fonction servant alors à entrer les données dans le programme ( Comme les fonctions sur la TI 89 , ou les procédures en Maple)
Cependant :
f =function (x) { 0.5*x^2 – 2*x } # définit une "vraie fonction " curve(f,-2,2) # trace la courbe
f( c(1,2,4,8))
# donne une série de valeurs cbind(–5:5,f(–5:5))
# donne une table de valeur
Quand on doit effectuer plusieurs instructions à la suite ,
on peut les écrire sur un seule ligne , séparées par des points virgules . cependant quand ligne s'allonge cela devient peu pratique .
On peut grouper les instructions dans une fonction .
> integrate(f,0,1)
-0.8333333 with absolute error < 4.6e-15
Pour calculer la valeur numérique d’une intégrale :
mais cette fonction de R renvoie en même temps la précision ; en fait R renvoie un vecteur ( valeur , précision )
Pour utiliser le résultat dans un calcul ultérieur , on souhaite ne retenir que la valeur . créons un fonction pour cela
Int=function(f,a,b){int=integrate(f,a,b) ;as.numeric(int[1])} #utilisons la
> Int(f,0,1) [1] -0.8333333
# la méthode des rectangles ( pour le calcul d'intégrales )
methrect = function (f,a,b,h){
x = seq(a,b-h,h);xx=x+h; y=f(x);yy=f(xx);m=min(y,yy) ;M=max(y,yy) ; plot(c(a,(a+b)/2,b),c(m,0,M),type=”n”); rect(x,0,xx,y,col="green"); rect(x,y,xx,yy,col="yellow"); curve(f,a,b,col="red",lwd=2,add=T); l=c(h*sum(y),h*sum(yy),Int(f,a,b)); names(l)=c(“rectinf”,”rectsup”,”integrale”);l } La fonction ci dessus
regroupe les instructions successives d'un tracé précédent ;
En y réfléchissant methrect se présente comme une fonction de fonction . Bien entendu f a du être définie au préalable (et porte peut être un autre nom)
Pour plus de clarté il est bon de préciser :
methrect = function (func=f,binf=a,bsup=b,pas=h){ etc }
Les instruction d'une fonction doivent toujours être écrites entres accolades Toutes les variables utilisées entre accolades sont des variables locales :
Si auparavant a désignait un vecteur ,par exemple , sa valeur n'a pas été modifiée . Une fonction retourne seulement le dernier objet écrit avant l'accolade finale ; si on veut voir s'afficher un résultat complexe (plusieurs nombres )
, il faut penser à la structure de ce dernier objet : vecteur ,matrice , table etc
Cependant , on peut obtenir à la fois un résultat numérique et un ou plusieurs graphiques . Voir l'exemple de methrect ci dessus .
Il est peu pratique d'écrire un fonction directement sur la console de R;
le mieux est de fignoler sa fonction sur le bloc note et de faire des copier coller sur la console jusqu'à être satisfait du résultat ;
On peut ensuite la documenter et l'enregistrer dans un fichier qui regroupe toutes les fonctions dont on pense avoir l'utilité : elles sont alors toujours à portée de main ,
prêtes à être copiées – collées
On peut également enregistrer ces fonctions directement dans R voir chapitre XIII
table
VI) Les tableaux de données
1) Utiliser un tableau déjà enregistré
de nombreuses données sont disponibles( dans la version R1051 dans "File" , "display file" , ouvrir le dossier "library" , puis "base" , puis "data" , puis"Rdata")
( dans la version R2001 , aller d'abord dans le dossier "library" , puis "datasets" , vous y trouverez un dossier "R-ex" à décompresser )
sélectionner par exemple " airquality.tab " , ouvrir .
on obtient le tableau suivant ( dont je ne reproduis que le debut , ça va jusqu'au 30 septembre )
Ozone Solar.R Wind Temp Month Day 41 190 7.4 67 5 1 36 118 8 72 5 2 12 149 12.6 74 5 3 18 313 11.5 62 5 4 NA NA 14.3 56 5 5 28 NA 14.9 66 5 6 23 299 8.6 65 5 7 19 99 13.8 59 5 8 8 19 20.1 61 5 9 NA 194 8.6 69 5 10 7 NA 6.9 74 5 11
Ceci permet de consulter le contenu de "airquality"
Cela vous convient : vous voulez travailler sur ces données . fermer la fenêtre ou elle sont affichées .
puis charger ces données par > data(airquality) > airquality
# pour les afficher mais ce n'est pas très intéressant , il y en a trop ! # une meilleure manière de consulter les données :
> edit (airquality) # édite les données en un tableau
Vous pouvez redimensionner les colonnes , modifier les titres de colonnes , modifier le contenu des cellules , etc : pour en savoir plus ,
Par un clic droit de la souris , vous obtenez un menu contextuel : choisir help
Pour pouvoir retourner à la console de travail , il faut fermer le tableau . >help(airquality) # documente les données
On peut maintenant travailler sur les données >Ozone # noter le "O" majuscule
Error: Object "Ozone" not found
>attach(airquality) # permet de disposer des vecteurs colonnes >Ozone # maintenant ça marche
[1] 41 36 12 18 NA 28 23 19 8 NA 7 16 11 14 18 14 34 6 [19] 30 11 1 11 4 32 NA NA NA 23 45 115 37 NA NA NA NA NA [37] NA 29 NA 71 39 NA NA 23 NA NA 21 37 20 12 13 NA NA NA [55] NA NA NA NA NA NA NA 135 49 32 NA 64 40 77 97 97 85 NA [73] 10 27 NA 7 48 35 61 79 63 16 NA NA 80 108 20 52 82 50 [91] 64 59 39 9 16 78 35 66 122 89 110 NA NA 44 28 65 NA 22 [109] 59 23 31 44 21 9 NA 45 168 73 NA 76 118 84 85 96 78 73 [127] 91 47 32 20 23 21 24 44 21 28 9 13 46 18 13 24 16 13 [145] 23 36 7 14 30 NA 14 18 20 > mean(Ozone)
[1] NA # signifie non affecté
> ?mean #pour consulter l'aide sur cette fonction OK : le pb vient du fait qu'il y a des valeurs NA !
on peut calculer la moyenne en ignorant ces valeurs > mean(Ozone,na.rm=T)
[1] 42.12931 > summary(Temp)
# des degrés fahrenheit !
on voudrait faire des graphiques , mais jour et mois ne nous intéressent pas fabriquons un nouveau tableau de données
> air=data.frame(Ozone,Solar.R,Wind,Temp) > boxplot(air)
Ozone Solar.R Wind Temp
0 50 1 00 15 0 20 0 25 0 300 >plot(air) Ozone 0 100 200 300 60 70 80 90 05 0 1 0 0 1 5 0 0 1 00 2 00 300 Solar.R Wind 51 0 1 5 2 0 0 50 100 150 6 0 70 80 9 0 5 10 15 20 Temp table
2) fabriquer son propre tableau :
( vous pouvez copier-coller directement sur la console les lignes suivantes )
s=c("f","f","m","f","f","m","m","m","f","f","m","f","f","m","m"," m","f","f","m","f"); t=c(1.65,1.54,1.59,1.57,1.68,1.85,1.78,1.69,1.71,1.52,1.86,1.67,1 .69,1.82,1.75,1.84,1.54,1.62,1.74,1.72); p=c(54,51,58,49,56,78,79,85,95,57,75,79,54,86,80,64,80,60,62,61); d=data.frame(s,t,p); colnames(d)=c("sexe","taille","poids")
sur les premières lignes , on crée enregistre des données
à la 6ème , on les rassemble en un tableau 20 lignes ,3 colonnes enfin on donne un nom à chaque colonne .
Notre banque de données est prête .On souhaite maintenant en faire l'analyse
>d
sexe taille poids 1 f 1.65 54 2 f 1.54 51 3 m 1.59 58 4 f 1.57 49 5 f 1.68 56 6 m 1.85 78 7 m 1.78 79 8 m 1.69 85 9 f 1.71 95 10 f 1.52 57 11 m 1.86 75 12 f 1.67 79 13 f 1.69 54 14 m 1.82 86 15 m 1.75 80 16 m 1.84 64 17 f 1.54 80 18 f 1.62 60 19 m 1.74 62 20 f 1.72 61
Voici une autre manière , préférable me semble t'il , de créer ce tableau de donnée ( dataframe en anglais ) nous l'appellerons cette fois dd
remplissez la ligne de texte : "sexe" , puis cocher " caractères " , puis fermer cliquez sur var2 , baptisez cette colonne " taille" , cocher "numérique "
idem pour la 3ème colonne
remplissez ensuite les colonnes avec les valeurs indiquées . Quand le tableau est à votre convenance fermez le
>dd # permet d'afficher le tableau
Une supposition que vous ayez oublié quelquechose , ou que vous souhaitiez modifier quelques valeurs .
Si vous vous contentez de rappeler le tableau par edit (dd) ,
vous pourrez effectuer les modifications , mais elles ne seront pas enregistrées ! Si vous souhaitez que les modifications soient effectives faites plutôt :
> dd=edit(dd)
Et si vous souhaitez conserver le tableau dd , faites >ddd=edit(dd)
Les 2 versions seront alors disponibles
"save to file" permet d'enregistrer le tableau au format ".txt " "save workspace" permet de l'enregistrer au format ".RData" mais attention c'est toute la feuille de travail qui est enregistrée ! Donc au préalable , vider l'écran par "misc" , " remove all objects" Puis créez vos données , puis enregistrer les .
Plus de détails dans le dernier chapitre
Maintenant travaillons sur d ou sur dd
> poids # renvoie un message d'erreur : variable inconnue ! > attach(d) # permet d'utiliser les colonnes comme vecteurs , en les appelant simplement par leur nom > poids # renvoie maintenant la liste attendue
>boxplot(taille ~ sexe,col=c(6,4)) # 2 diagrammes , en fonction du sexe
>boxplot(poids ~ sexe) # idem
>plot(poids,taille);abline(lm(taille~poids))
on a ajouté un droite de régression ( voir plus loin)
mieux encore :
>plot(d) # funny is't it !
3) la fonction tapply
> tapply(taille,sexe,mean) f m 1.628182 1.768889 > tapply(poids,sexe,mean) f m 63.27273 74.11111 > tapply(taille,sexe,sd) f m 0.07386720 0.08809717 > tapply(taille,sexe,fivenum) $f [1] 1.520 1.555 1.650 1.685 1.720 $m [1] 1.59 1.74 1.78 1.84 1.86La fonction apply et ses nombreuses variantes , tapply , mapply , etc , applique à la première liste la fonction écrite en dernier ,
suivant un critère tiré de la seconde liste .
les fonctions sont ici mean , puis sd , puis fivenum , le critère étant le sexe
mais on aurait pu essayer aussi quantile avec des données plus nombreuses
4) des fonctions de tri
on a déjà vu which , voici subset et split
> pm=poids[sexe=="m"];pm # sélectionne les poids masculins > subset(d,sexe=="f")
# extrait un sous tableau suivant le critère choisi >st=split(d$taille,d$sexe) # donne 2 listes de taille suivant le sexe
puis order
> o=order(poids)
[1] 4 2 1 13 5 10 3 18 20 19 16 11 6 7 12 15 17 [18] 8 14 9
donne les indices de poids croissant : le plus petit poids est le 4ème à savoir 49 , puis vient le 2d , on trouve le plus grand poids en 9ème position
>taille[o] # range les tailles par ordre croissant des poids >plot(taille[o],type="l")
>plot(poids[o],type="l")
>dp75=subset(d,poids>75) >attach(dp75)
# on peut maintenant reprendre toutes les analyses précédentes sur le sous tableau nommé dp75
j'arrête ici , le sujet est trop vaste , en consultant l'aide vous allez trouver des centaines d'exemples de ce que l'on peut faire.
table
VII) Les couleurs
>a=runif(1000)>b=rep(1:10,100)
>boxplot(a~b,col=rainbow(10),notch=T) #Comparer divers tirages suivant la même loi :
0 .0 0 .2 0 .4 0 .6 0 .8 1 .0
Explication : b consiste en 100 répétitions de la liste 1 , 2 , , 10 les vecteurs a et b sont comparés ;
a est découpé en 10 vecteurs de taille 100 , le critère du tri étant les niveaux indiques par b .
(c'est à dire que sont groupés les termes d'indice 1,11,21,31,,,981,991 de la liste a , puis les termes d'indice 2,12,22,32,,,,,982,992, etc ,
de manière à former 10 tirages de 100 , a partir d'un seul tirage de 1000)
Pour chaque échantillon de 100 , c'est à dire pour chaque niveau de b , une boite est tracée . rainbow(10) donne 10 nuances de couleurs ( ou 20 si avez 20 tracés ) ;
heat.colors(n) ou gray(n) peuvent aussi être utilisés ;
col=2:3 recycle les couleurs numérotées 2 et 3 ( rouge et vert) pour atteindre la taille voulue , ici 10 .
> hist(runif(1000),col=2:3,breaks=seq(0,1,0.05))
> hist(runif(1000),col=2:7,breaks=seq(0,1,length=20))
consulter l'aide : ?colors pour voir les 657 couleurs disponibles ? palette et ?rgb pour créer vos propres couleurs .
essayez : > x= rep(1,36) >pie(x,col=rainbow(36)) > pie(x,col=gray((1:36)/36)) > pie(x,col=heat.colors(36)) > pie(x,col=terrain.colors(36)) > pie(x,col=topo.colors(36)) > pie(x,col=cm.colors(36))
Pour terminer , on peut enregistrer , copier et coller les graphiques sous 2 formats : Bitmap et metafile ;
sélectionner "file" , "copy to clipboard" , puis coller dans votre document
J'ai utilisé essentiellement le premier : la second est de bien meilleure qualité ,
mais coûteux en espace mémoire .Le pressent document , que j'ai voulu abondamment illustré , serait devenu trop beaucoup trop gros .
Cependant c'est le second format qui s'impose si vous voulez créer de jolis documents .
VIII) Enfin des simulations
simulation1
# on lance 600 dés dont une face est noire les autres blanches;
#soit X1 la VA nombre de dés sur la face blanche ;X1 suit la loi B(600,5/6); #Les dés noirs sont retirés du jeu , et on recommence ;
#soit X2 la VA nombre de dés sur la face blanche ; X2 suit la loi B(X1,5/6); etc ,etc # Xn ( nombre de dés restant en jeu à l'issue de n lancers ) suit la loi B(Xn–1 , 5/6); #comment simuler cette expérience ?
#allons au plus simple : >a=600;
>a=rbinom(1,a,5/6);a; [1] 502
>a=rbinom(1,a,5/6);a; #on rappelle la ligne précédente et on l'exécute à nouveau [1] 406 >a=rbinom(1,a,5/6);a; # etc [1] 342 > a=rbinom(1,a,5/6);a; [1] 280 > a=rbinom(1,a,5/6);a; [1] 233
# Pour mieux suivre l'évolution ,
#on peut ranger les valeurs successives de a dans un vecteur v . a=600;v=c(a)
while(a>0){a=rbinom(1,a,5/6);v=c(v,a)};v
#Il est assez logique de comparer v à la suite 600*(5/6)^n vv=720*(5/6)^(1:length(v));
#graphiquement
plot(v,col="red",bg="red",pch=21) points(vv,col="blue")
# le plus grand écart en valeur absolue , puis la moyenne de ces écarts # et la moyenne des carres de ces écarts
max(abs(v-vv)); mean(abs(v-vv));mean ((v–vv)^2)
simulation 2 ( suite de la précédente )
#soit N la variable aléatoire nombre de lancer nécessaires pour que XN = 0 #elle peut être obtenue par la ligne
a=600;v=c(a);while(a>0){a=rbinom(1,a,5/6);v=c(v,a)};length(v) # que l'on rappelle à volonté
# bien sur on voudra collecter ces valeurs , puis en faire un diagramme , pour avoir une idée #de cette loi
f=function(){ a=600;v=c(a);
while(a>0){a=rbinom(1,a,5/6);v=c(v,a)}; length(v) }
# on groupe les calculs dans un petit programme sans paramètre #il suffit d'écrire f() pour obtenir le même résultat que précédemment #allons plus loin
# la fonction ( ou le programme) suivant calcule n valeurs de N # et renvoie un diagramme , ainsi que la moyenne et l'écart type
g=function(n){u=c();
for ( i in 1:n) u=c(u,f()) ;
barplot(table(u));c(mean(u),sd(u))} # il suffit maintenant d'écrire
g(100) g(1000)
# ou bien ( temps d'attente de l'ordre de la minute ) g(10000)
simulation 3
# On tire successivement sans remise 3 boules dans une urne # qui contient 3 rouges , 3 vertes et 2 noires
#quelle est la probabilité que la troisième soit noire ?
urne = c( rep("rouge",3),rep("verte",3),rep("noire",2)) a= sample(urne,3);a
a[3]
#il s'agit de faire un grand nombre d'essais res=c()
for(i in 1:1000){u = urne; res=c(res,sample(u,3)[3])};table(res)
# pour que ce soit plus pratique groupons cela dans une fonction
h=function(n) { res=c();
for(i in 1:n){u = urne;res=c(res,sample(u,3)[3])}; table(res)}
# on peut maintenant essayer h(10000)
#il semble que la probabilité cherchée soit de 0.25
en effet , prenons une boule rouge et une verte et repeignons les en bleu ! #l'urne contient 4 couleurs equiréparties
#il n'a pas de raison qu'une couleur sorte en dernier plus souvent qu'une autre
#pour analyser les résultats d'un tirage , il est pratique de coder les couleurs noire par 1 , verte par 10 et rouge par 100
urne=c(1,1,10,10,10,100,100,100)
sum(sample(urne,3)) # le tirage est codé par un nombre , mais l'ordre est perdu
k=function(n) { res=c();
for(i in 1:n){u = urne;res=c(res,sum(sample(u,3)))}; table(res)}
# pour obtenir l'analyse du résultat de 1000 tirages k(1000)
Simulation 4
# X suit la loi binomiale B(10,0.4) et Y suit la loi B(10,0.6) #On cherche P(X>=Y)
#On effectue d'abord un tirage de 100 nombres suivant X # et 100 autres suivant Y
x= rbinom(100,10,0.4) y = rbinom(100,10,0.6)
#Il s'agit de savoir combien de valeurs de x sont supérieures #ou égales #au valeurs correspondantes de y
x>=y
#renvoie un vecteur logique ; on peut préciser ,( mais ce #n'est pas nécessaire)
as.numeric(x>=y)
#le nombre cherché est alors
sum(x>=y)
#100 paraissant insuffisant remplaçons par 10 000
#et groupons ces calculs de manière à pouvoir les répéter à #volonté
x= rbinom(10000,10,0.4);y = rbinom(10000,10,0.6);sum(x>=y)
#assez convaincant n'est ce pas ?
#quelques illustration complémentaires table(x,y)
#les gains de X sur Y se lisent dans la partie inférieure #gauche de la table barplot(table(x,y))
# pour chaque niveau de Y , la répartition des valeurs de X barplot(table(x,y),beside=T)
#variante du précédent
#Procédons maintenant au calcul exact de la probabilité #Il s'agit de sommer , pour k allant de 0 à 10
#les nombres P(X=k)*P(Y<=k)
dx=dbinom(0:10,10,0.4);dx
#donne le vecteur des probabilités X=k , k allant de 0 à 10
py=pbinom(0:10,10,0.6);py
#donne le vecteur des probabilités Y<=k , k allant de 0 à 10 sum(dx*py) # donne la probabilité cherchée
simulation 5
le problème du collectionneur consiste à compléter sa collection de 6 images ,
sachant que les images sont reparties aléatoirement dans les boites de céréales (une par boite ), combien doit il en moyenne acheter de boites pour avoir les 6 images ?
On modélise en lançant un dé la fonction f() effectue un essai
un vecteur de longueur 7 est initialisé à 0;
au fur et à mesure qu'un numéro sort , il est rangé dans l : le nombre j va en jième position ,
cela jusqu'à ce que les six premières cases soient pleines(!==0); la 7ème sert de compteur
>f= function(){l<-rep(0,7);
while(min(l)==0){
j <-ceiling(6*runif(1)); l[j]<-j;l[7]<-1+l[7]} ;l[7]}
# nb : f n'a pas d'argument , on l'appelle simplement par > f()
# la fonction g effectue n essais , donne moyenne , écart type et répartition ; >g=function(n){ x<-c(); for (i in 1:n) { x[i]<-f()} print(mean(x));print(sd(x)); table(x)}
#on peut terminer par :
> a<-g(1000);barplot(a)
#avec n =100 000 , j'ai trouvé une moyenne de 14.660 et un écart type de 6.217 mais c'est assez long
variante infiniment plus rapide , mais réservée aux profs
h=function(n){
x=rgeom(n,5/6)+rgeom(n,4/6)+rgeom(n,3/6)+rgeom(n,2/6)+rgeom(n,1/6); barplot(table(x+6));c(mean(x+6),sd(x))}
n=1 000 000 donne m=14.7 et sd= 6.25
Simulation 6
Un jeu se solde par succés ou échec ,avec probabilité p de succés . On joue jusqu'à obtenir 6 succés consécutifs .
Combien de temps en moyenne cela necessite t'il ?
>sample(c(0,1),6,T,prob=c(1-p,p)) permet de voir le resultat de 6 essais
>seriede6=function(p){
S=sample(c(0,1),6,T,prob=c(1-p,p)); L=6; while(sum(S[(L-5):L])<6){
S=c(S,sample(c(0,1),1,prob=c(1-p,p)));L=L+1}; L}
commentaire : à la première ligne ,on initialise
puis tant que la somme des 6 derniers termes est < 6 , on effectue un tirage supplementaire ;
à l'affichage , on obtient le nombre de tirages pour le gain
nb : si on veut en outre afficher la serie elle même , il suffit de remplacer L par c(S,L)
un problème ici est que l'ecart type est très grand , on a donc une grande dispersion des résultats ; Essayons cependant sur un grand nombre de series :
> time=0;for(i in 1:1000) time=time+seriede6(0.5);time/1000 [1] 124.327
Si p =0.5 , le resultat exact est T = 26 – 2 = 126 avec un ecart type de 121
table
simulation 7
la vie d’une particuleUne particule se déplace sur un segment de longueur 1 Et peut occuper 11 positions : 0 , 0.1 , 0.2 etc jusqu’à 1 Elle saute aléatoirement d’une position à une autre mais
Chaque extrémité exerce sur elle une attraction , d’autant plus forte qu’elle en est plus proche . Si elle est en position p , sa prochaine position sera donnée par la loi binomiale B(10,p) ; Il est clair que si elle atteint une des bornes , elle y restera collée éternellement ;
Quelle est la durée de vie moyenne d’une particule ?
f=function(){p=rbinom(1,10,0.5)/10;k=0;
while(p!=0 & p!=1) { p=rbinom(1,10,p)/10;k=k+1};c(k,p)}
# on fait 100000 essais
s=0;for(i in 1:100000)s=s+f();s/100000
# on trouve 11,5 et 1 chance sur 2 pour chaque extremité
# au départ la particule est en 0.5 avec probabilité 1 #c'est le vecteur d'etat initial
B=c(0,0,0,0,0,1,0,0,0,0,0)
# on definit la matrice de transition d'un état au suivant # puis on la formate
AA=c();for(i in 0:10) AA=c(AA,dbinom(0:10,10,i/10)) A=matrix(AA,11,11)
# un premier essai montrant les probabilités de l'etat 1 B=A%*%B matrix(c(0:10,B),11,2) [,1] [,2] [1,] 0 0.0009765625 [2,] 1 0.0097656250 [3,] 2 0.0439453125 [4,] 3 0.1171875000 [5,] 4 0.2050781250 [6,] 5 0.2460937500 [7,] 6 0.2050781250 [8,] 7 0.1171875000 [9,] 8 0.0439453125 [10,] 9 0.0097656250 [11,] 10 0.0009765625 # on itere l'operation for(i in 1:1000) B = A%*%B matrix(c(0:10,B),11,2) [,1] [,2] [1,] 0 5.000000e-01 [2,] 1 5.432921e-52 [3,] 2 6.209235e-52 [4,] 3 6.437669e-52 [5,] 4 6.534059e-52 [6,] 5 6.563114e-52 [7,] 6 6.534059e-52 [8,] 7 6.437669e-52 [9,] 8 6.209235e-52 [10,] 9 5.432921e-52 [11,] 10 5.000000e-01
Les probabilités de l'etat limite sont (0.5,0,0,0,0,0,0,0,0,0,0.5)
simulation 8
le nombre de profs à l'apmep
Aux journées de l’ APMEP le nombre de participants est inférieur à 1000
Chaque participant porte un badge ou est inscrit son nom et son numéro d’inscription ; Au bout de 5 minute , j’ai observé les numéros suivants :
23 201 808 452 649 59 160 234 366 636 que penser du nombre de participant ?
Suggestion :
n= round(1000*runif(1)) tire un nombre (qu’on n’affiche pas) s= sample(1 :a, 10) nous donne un échantillon de 10 numéros ; on choisit comme estimateur de n le maximum de s ;
puis on compare à n ;
effectuant ceci un grand nombre de fois , et en effectuant une statistique sur les résultats, on verra quelle fiabilité accorder à notre estimateur .
simulation 9
Tir à l'aveugle( un PB du petit vert (bulletin de APMEP région Lorraine ) de décembre 2003 ) une pile de n jetons est soumise à un tir aléatoire ;
le jeton touché ainsi que tous ceux qui se trouvent au dessus tombent ; on continue le tir sur la pile restante ; à chaque étape il y a équiprobabilité . Combien en moyenne faut il de tirs pour raser la pile ?
N étant la V.A. nombre de tirs nécessaires , peut on avoir une idée de la loi de N?
Pour avoir commis un fichier "Excel" sur la question , je peut témoigner : C'est plus pratique et plus rapide avec R !
Mais on peut faire énormément de choses avec "Excel" :
si vous êtes intéressés , vous pouvez charger ce fichier à l'adresse http://www.ac-nancy-metz.fr/enseign/maths/APMEP/
puis " solution des problèmes précédent , pb numéro 76"
#la valeur exacte de E(N) est donnée par > p=1:n;e=sum(1/p)
#voir l'annexe pour une justification , ainsi que pour la loi de N .
la fonction suivante donne le résultat d'un essai en detaillant les hauteurs intermédiaires . > ncoup=function(n){list=c();h=n;k=0; while(h>0){ h=sample(1:h,1)-1;list=c(list,h); k=k+1} ;c(list,k)} # le résultat brut > nbrcoup=function(n){h=n;k=0; while(h>0){ h=sample(1:h,1)-1; k=k+1} ;k}
#On enregistre le résultat de m essais portant sur des piles de hauteur n puis on analyse le résultat
>lcoup=function(m,n){lc=c();for(i in 1:m){ lc=c(lc,nbrcoup(n))}; barplot(table(lc));mean(lc)} > lcoup(10000,200) [1] 5.8475 > a=1:200;sum(1/a) [1] 5.878031
si on veut se livrer à des analyses plus poussée sur la liste , le programme doit renvoyer la liste elle même > lcoup=function(m,n){lc=c();for(i in 1:m)
{ lc=c(lc,nbrcoup(n))};lc} > liste=lcoup(200,100)
un détail utile : si vous vous contentez d'écrire >lcoup(10000,200) , le résultat sera l'affichage des 10000 valeurs ;
la seconde ligne permet d'éviter cela ;
En outre si vous demandez >lc , vous obtiendrez un message d'erreur : "objet inconnu" En effet "lc" est une variable locale !
Toute variable utilisée dans un programme est locale ;
Si une variable de même nom existait au préalable , sa valeur n'est affectée en rien par l'exécution du programme
simulation 10
Tir à l’aveugle (une variante continue du précédent ) Un segment à pour hauteur x > 1
on tire en visant au hasard et on le découpe à la hauteur y = x*runif(1) puis on recommence jusqu'à obtenir une hauteur < 1 ;
Combien de tir sont nécessaires en moyenne ?
La solution la plus simple est d’écrire un petit programme ( une fonction) Qui calcule des valeurs successive de la hauteur jusqu’à obtenir y >1 ; Ceci peut être fait avec la fonction while ( tant que ) ou repeat ( jusqu'à )
table
Simulation 11
vous êtes invité ainsi que 10 autres personnes à une soirée ; chacun arrive au hasard entre 7 et 8 heures ;
soit N le nombre de personnes qui arrivent avant vous ; quelle est la loi de N ?
(On doit supposer que ces 11 personnes ne se connaissent pas , ce qui permet de supposer l'independance de leur heure d'arrivée )
1)première approche
On considère une VA U suivant la loi uniforme sur [0,1], puis 10 VA indépendantes ,
X1,X2, ..., X10 , suivant également la loi uniforme sur [0,1]. On pose N = nombre d'indices i tels que Xi <U ;
Quelle est la loi de N ? simulation : # un seul essai : l=runif(11);l;l[l<l[1]];length(l[l<l[1]]) # ou bien l=runif(11);l;l<l[1];sum(l<l[1]) #1000 essais :
test=c() # on déclare une liste vide
for ( i in 1:1000){ l =runif(11) ; test[i]=sum(l<l[1])} # on enregistre dans test le résultat de 1000 essais
t = table(test) ; barplot(t); # on observe les résultats
# n essais :
ff = function(n) {test=c();
for ( i in 1:n){ l =runif(11) ; test[i]=length(l[l<l[1]])};
#On observe que le temps d'attente n'est pas négligeable . #En fait on peut mieux faire .
2) autre approche
soit Nk = 0 ou 1 suivant que Xk<U ou Xk>U ; N = N1+N2+ ... +N10 ;
les Nk suivent la loi de bernouilli de paramètre U ; Donc N suit la loi binomiale B( 10, U) .
On considère donc une V.A. U suivant la loi uniforme sur [0,1] et la variable aléatoire N = B (10 , U ) ,
suivant la loi binomiale de taille 10 et de probabilité U ; Montrer que N suit la loi uniforme sur { 0,1,2,3, ... ,9,10} .
#Simulons d'abord N .
x=rbinom(100000,10,runif(100000));t=table(x);barplot(t);t;
#On effectue 100000 tirages de X , la valeur de U changeant à chaque fois .
gg= function (n)
{x=rbinom(n,10,runif(n));t=table(x);barplot(t);t} ;
#cette fonction permet de répéter l'opération en faisant varier n .
3) explication
N = k signifie que U vient se ranger en (k+1) ème position dans la liste X1,X2, , ...., X10 rangée par ordre croissant . comme les variables sont indépendantes ,
il n'y a aucune raison pour qu'une position de U soit privilégiée ! donc P(N=k) = 1/n+1 cqfd
table
Simulation 12
un classique : l'urne de Polya
une urne contient initialement une boule blanche et une noire ;
on tire une boule .Si elle est blanche on la remet dans l'urne avec une seconde boule blanche , Si elle est noire on la remet dans l'urne avec une seconde boule noire .
on note Pn la proportion de blanches au bout de n tirages ;
Il s'agit de tester à l'aide de simulations les 2 hypothèses suivantes : 1) la suite Pn est convergente ; nommons P sa limite ;
2 ) Les valeurs de P sont uniformément réparties sur [0,1]
