###########################################################################################
##        HAB711B Description et inference DESINF -- séances TP #1 et #2     ##
##Introduction à R et manipulation de données ##
###########################################################################################


##### Les salles de TP et le système d'exploitation

# En TP, les ordinateurs sont équipés d'un système d'exploitation linux.
# Contrairement à Windows ou Mac, Linux offre de nombreuses distributions libres
# et gratuites. La plupart des distributions Linux sont reconnues pour leur style
# épuré et leur simplicité. Certains réflexes que vous avez acquis sur d'autres 
# systèmes d'exploitation peuvent être différents (touches racourci), mais vous
# verrez vite que cet environnement simplifié peut avoir des avantages.
# Sous Linux, pour démarrer la session R, il vous faudra ouvrir un terminal
# (vous trouverez ce terminal dans les logiciels de votre ordinateur, l'icône
# correspond à un petit écran noir)
# Par défaut, vos feuilles de TP seront ouvertes par l'éditeur de script de 
# Linux. Cet éditeur interprète directement le language du script, et devrait 
# faire apparaître les éléments du script de couleurs différentes.
# Si vous travaillez avec Windows et voulez avoir cette fonctionalité, et qu'il
# n'est pas installé, vous pouvez télécharger et installer le logiciel gratuit gedit. 


##### R en bref

# R est un logiciel libre, multiplateforme et gratuit qui permet de faire des
# statistiques.
# C'est ajourd'hui  un des outils informatiques phares dans le domaine, en
# particulier en biologie. Il s'appuie sur un langage informatique et un
# environnement propre (R).
# R exsite depuis plus de 25 ans, il est gratuit, constamment amélioré par une 
# très large communauté ouverte de chercheurs et de passionnés. 
# R fonctionne en ligne de commandes, ce n'est donc pas un logiciel presse 
# bouton. Ces commandes peuvent être annotées et stockées sous forme de texte
# appelées script. Un avantage énorme de ce fonctionnement permet de sauvegarder
# l'ensemble des opérations qui ont été faites, de les échanger, de les adapter, 
# et de les améliorer.

##### Le script et les commentaires

# Vous avez ici une feuille de script, une feuille de script est une série
# de commentaires pour vous aider à comprendre une série de commandes qui
# permettent d'interagir avec votre ordinateur. Les commentaires de ces 
# feuilles sont écrits pour le langage R que vous allez apprendre durant ces
# séances. Chaque ligne de commentaire est précédée d'un signe dièse.
# Ainsi quand vous copierez et collerez ces commentaires lors d'une session
# R, ils ne seront pas lus comme des ordres pour votre machine.

# Les commentaires sont utiles, car ils permettent d'avoir des indications sur 
# les explications des commandes qui seront envoyées à l'ordinateur. Nous 
# vous conseillons donc de sauvegarder cette feuille de script, mais aussi 
# de la compléter avec votre propres commentaires ou réponses aux exercices.
# Vous conserverez ainsi une trace de votre TP que vous pourrez imprimer, et 
# reproduire dans R. 

######1. Utilisation de R comme d'une calculatrice
# Démarrez R. Pour cela ouvrez le terminal et tapez R. On vous demandera
# de taper un certain nombre de commandes contenues dans les feuilles de
# script, de les copier/coller et les analyser et parfois de les compléter.

# Notez que la ligne de commande démarre par le signe >.
# Cela signifie que R attend vos commandes (vos ordres).
# Si ce n'est pas le cas, R attend autre chose: dans ce cas 
#1.soit rien n'apparait (il faut alors interagir avec une autre
# fenêtre (un graphique ou bien l'éditeur du jeu de donnée). 
#2. soit un + apparait  en début de ligne, ce qui veut dire que votre commande
#  est incomplète.

# R permet de faire des calculs simples, en écrivant des opérations qui font
# intervenir des vecteurs (des nombres) et des opérateurs (signes de calcul)

1+1.1


##Q1. Que ce passe t'il à l'exécution de cette commande ? 
#après l'exécution de la commande le résultat de l'opération est imprimé dans la console
# Notez que la virgule correspond au point.
# De quoi le résultat est-il précédé ?
#Le résultat est précédé d'un numero entre crochets, ce numéro indique l'indice (la position) du premier élément de la ligne

10/2

# Dans R, les opérateurs +,-, *,/, %/%, %%  permettent respectivement de faire
# des additions, soustractions, multiplications, divisions, divisions entières  
# et obtenir le reste entier.

# L'opérateur ; permet de produire deux commandes sur la même ligne
10/2; 10%%2
# Il est ainsi possible de faire des opérations multiples sur une même ligne

10+2*3
#Q2. Que constate - t - on ici ?
#La multiplication est prioritaire sur l'addition, R fonctionne comme une calculette scientifique
# Pour gérer le flux des opérations, on utilise le double opérateur parenthèse ()
# Comme pour tout opérateur double, toute parenthèse ouverte doit être fermée, sous
# peine d'un message d'erreur, ou bien d'un retour de R par le signe + qui indique que
# vous n'avez pas terminé votre commande
# par exemple:
10+(2*3
#fait intervenir le signe + à la ligne, il faut alors taper la parenthèse fermante pour
#terminer la commande
)

(10+2)*3
#on le voit ici, les parenthèses permettent de gérer les priorités entre opérations. 

# L'opérateur ":" permet de faire des suite régulière d'entier, il a priorité sur les opérateurs arithmétiques.
1:30
1:30*2
### Les constantes et les fonctions dans R.

pi
# Par défaut, quel est l'unité des angles dans R?
# pi est une constante, sa valeur est accessible en tapant pi. De manière général, pi est 
# un objet dans R. Il existe d'autres constantes dans R, vous pouvez y accéder via l'aide 
# en ligne
?pi
# Dans linux pour fermer l'aide en ligne, il faut taper q

# R permet également l'utilisation de fonctions. Ces fonctions permettent également de faire
# des opérations, de retourner des graphiques, et de faire beaucoup d'autres choses.

cos(pi)
cos(2*pi)


# L'aide en ligne dans R vous permet de comprendre l'utilisation des fonctions. On peut 
#par exemple,  demander l'aide en ligne pour cos.
?cos
# Dans l'aide en ligne de la fonction cos, on voit que pour l'utiliser, il faut préciser un argument x
# cet argument ou variable n'existe pas dans R. Comme on peut le voir lors de la commande suivante.
x
# Il permet juste de vous montrer à quoi doit correspondre x dans la fonction. Vous pouvez
# le lire dans la suite de l'aide en ligne (usage et arguments). Lors de l'appel à la fonction cos,
# x doit donc être substitué une valeur numérique ou complexe pour que la fonction retourne un résultat.


# Certaines fonctions nécessitent des arguments multiples, ces arguments multiples doivent
# être séparés par des virgules. C'est le cas de la fonction lm, qui permet de faire des 
# modèles linéaires
?lm

# Notez qu'à la fin de l'aide en ligne, vous avez un tuteur. C'est à dire un exemple de 
# ce que la fonction peut produire. Pour exécuter ce tuteur et voir ce qui se passe, on 
# tape par exemple.
example(cos)

# D'autres fonctions admettent également des arguments qui peuvent être multiples, mais 
# leur nombre n'est pas spécifié à priori. Dans ce cas, ces arguments apparaissent sous
# la forme de ...
?c

# La fonction c est une fonction importante car elle permet d'entrer une suite de données
# en format vectoriel.
c(1,3,1)

#### Les différents type d'objets dans R, l'assignation et l'indexation de ces objets.

# Au delà de la manipulation de nombres et de chiffres, R permet de manipuler différents
# types d'objet. Il peut s'agir de vecteurs (vectors) (suite d'élément de même nature), 
# des matrices (matrix),  des tableaux de tableaux (arrays), des jeux de données
# (data.frame), des listes (list) (ensemble d'éléments de nature diverse). L'accès aux
# éléments de ces objets se fait par une technique appélée indexation.

## Les vecteurs
# Pour créer un vecteur conntenant des objets de même type, on utilise la fonction c
c(1,3,1)
# Il est possible de conserver le résultat de cette commande en la stockant dans un 
# objet, on  parle encore d'assignation
a<-c(1,3,1)
#l'opérateur d'assignation est <-, il est possible aussi d'utiliser le signe =, mais 
#on préférera l'utiliser pour spécifier des arguments dans les fonctions.
a
# On peut ensuite faire des opérations sur cet objet
a*2
# Ou bien regarder des caractéristiques de cet objet comme sa longeur ou son mode
mode(a)
length(a)
# Pour construire un vecteur contenant des chaînes de caractères, ces dernières doivent
# être précédées et suivies du double opérateur " pour les disinguer des objets R ou des 
# valeurs numériques
b<-c("jiji", "jojo")
b
#Q3. Obtenez le mode et la longeur de b
mode(b); length(b)

#La coercition: tapez la commande suivante
a1<-c(a,b)
a1
length(a1)
mode(a1)
#Q4. Que s'est-il passé.
#les chiffres ont été transformé en mode caractères (cf les guillemets)  de sorte que les éléments du vecteur soient compatibles, on parle de coercition, comme un vecteur ne peux être composer que d'un seul type d'élément, R se débrouille pour les rendre compatible entre eux

##l'indexation numérique sur un vecteur. 
#On peut extraire une partie d'un objet en fournissant l'emplacement d'un ou de plusieurs
#éléments que l'on veut ensuite manipuler. L'indexation se fait grace au double opérateur []
a1[2]
a1[c(2,4)]
a1[-2]
#Q5. Que fait le signe - ici ?
#il permet d'enlever le deuxième élément dans a1

##les booléens
#en plus des vecteurs numériques ou de type chaines de caractères, il existe des vecteurs
# de booléens (vrai/faux) (logical dans R).
#ces vecteurs sont utiles car ils permettent de faire des comparaisons.
b1<-3:10
b1>5
b1>=5
b1==1
a1=="jiji"
b2<-b1==1
mode(b2)
length(b2)
##Il est possible de combiner les comparaisons avec les opérateurs et (&) ou ou (|)
#Q6. Comparez le résulat de ces deux commandes
b1>5 & b1<7
b1<5 | b1>7
#La commande ressort un vecteur booléens (composer d'éléments de type logical)
#dans le premier cas, on a vrai quand la valeur des éléments de b1 sont à la fois supérieurs à 5 et inférieurs à 7
#dans le second cas, on a vrai quand l'élément de b1 est inférieur à 5 ou quand il est supérieur à 7


#la fonction which permet d'indiquer l'emplacement des éléments dans un vecteur si ils 
#satisfassent à la condition vrai
b3<-b1>=5
which(b3)
#cette fonction peut être utile pour faire de l'indexaction numérique.
b1[which(b3)]
#cette commande permettra d'extraire les valeurs de b3 supérieures ou égales à 5
b1[which(b1>=5)]
#Cette seconde commande est équivalente.

#l'indexation logique
b3
b1[b3]
b1[b1>=5]
#Plus compacte,  cette indexation permet d'extraire les valeurs pour
#lesquelles l'indice correspond à vrai (TRUE). Ce mode d'indexation est très utilisé dans R.
#Il permet de se passer de which.

###Les matrices
#les matrices sont des vecteurs organisés en plusieurs colonnes et lignes
M<-matrix(1:10,5,2)
M
#Elles sont remplies par défaut colonnes par colonnes, le premier élément correspond au vecteur
#de données, le second au nombre de lignes, puis de colonnes.
M1<-matrix(1:10,5,2, byrow=T)
M1
#On peut aussi les remplir en lignes en spécifiant l'option byrow=T
#On peut facilement faire du calcul matriciel dans R. La transposée est obtenu par la fonction t
t(M1)
#Le produit matriciel est obtenu par l'opérateur %*%
t(M1)%*%M 
#Il est également possible d'indexer les matrices en lignes et en colonnes pour cela, il faut 
#utiliser la virgule. 
#Q7. Interprétez les commandes suivantes:
M1[1,]
M1[,1]
M1[-2,]
M1[1:2,]
M1[M1[,1]>3,]
#Les matrices comme les vecteurs peuvent être de type numeric, character ou logical. Elles ne peuvent
#pas contenir des éléments de différents modes.
#En plus d'une longeur et d'un mode, on peut extraire leur nombre de colonnes et lignes
dim(M)
dim(M1)
#La première valeur correspond au nombre de lignes, la seconde au nombre de colonnes.

##Les arrays (tableaux de tableaux) sont des matrices étendues à plusieurs dimensions
array(1:30,dim=c(2,5,3))
#Cette commande permet d'organiser les valeurs 1 à 30 dans 3 matrices de 2 lignes et 5 colonnes.
#Le remplissage se fera par matrices, colonnes, et lignes
A<-array(1:30,dim=c(2,5,3))
dim(A)
#Q8. indexez A de sorte à obtenir la deuxième matrice; ensuite indexez A de sorte à obtenir
# l'ensemble des premières colonnes 
A[,,1]
A[,1,]


##Les listes
#Les listes sont des objets qui permettent de stocker des objets de différents modes ou type.
#Elles sont obtenues grâce à la fonction list. De très nombreuses fonctions de R renvoient des objets
# de type list. Il est essentiel de savoir les indexer.
list(A, b1)
b4<-list(A, b1)
b4
#la longeur d'une liste correspond au nombre d'objets qu'elle contient 
length(b4)
#Pour indexer une liste on utilise l'opérateur [[]]; il permet d'extraire l'objet
b4[[2]]
#Il est possible ensuite d'extraire des valeur sur cet objet
b4[[2]][3]
#Cette commande extrairera le troisième élément du deuxième objet 
#Le mode d'une liste est de type list.
mode(b4)
#Les listes permettent également l'indexation nominale, pour cela il faut renseigner les noms
# des éléments de la liste à leur création 
b5<-list(objet1=A ,objet2=b1)
b5
#Q9. Qu'est qui a changé entre b4 et b5
#les objets de la liste sont précédés par leur nom plutot que par les doubles crochets autour de l 'indice
names(b5)
#Pour indexer une liste par nom, on utilise l'opérateur $
b5$objet1

##Les jeux de données (data.frame).
#En statistique, les jeux de données sont une présentation conventionnelle des données. Ils correspondent à des observations uni ou mulvariées (en lignes) et des variables en colonnes. Ces variables peuvent être de différents mode. Les data.frame sont en fait des listes de vecteur (variables) de même taille. R contient des jeux de données pour s'entrainer.
#Un exemple de jeu de données est ToothGrowth
?ToothGrowth
mode(ToothGrowth)
#les différentes variables peuvent être obtenues grace à names
names(ToothGrowth)
#l'indexation de ces jeux de données peut se faire comme pour une matrice ou une liste
ToothGrowth[,1]
ToothGrowth$len
#Il est d'usage dans les jeux de données d'avoir des facteurs (variables catégoriques). Les facteurs sont des vecteurs particulier contenant différentes catégories (levels). Ces vecteurs sont numériques, mais attention !!! Les valeurs numériques ne sont pas des entiers ou des réels, il s'agit plutot d'un codage binaire permettant de spécifier quelle est la catégorie correspondant à chaque élément (variable qualitative). 
str(ToothGrowth)
#On voit ici que la deuxième vecteur est un facteur
is.factor(ToothGrowth[,2])
#Q10. A l'aide de l'indexation, extraire les lignes du tableau qui correspondent à des cobayes pour lesquels on a donné du jus d'orange et pour lesquels les odontoblastes mesurent plus de 10 micrometres.  
ToothGrowth[ToothGrowth$len>10 & ToothGrowth[,2]=="OJ",]

#Il est possible de calculer des paramètres statistiques simples sur un jeu de données.
#Pour les variables numériques (mean, min, max, median, range, var, sd) renvoient respectivement la moyenne, le minimum, le maximum, l'étendue, la variance et l'écart type. 
#Q11. Calculez tous ces paramètres pour la variable longeur des odontoblastes pour les cobayes ayant reçu de la vitamine C. Faire de même pour les cobayes ayant reçu du jus d'orange.

#La fonction quantile permet d'extraire le quantile correspondant à une fréquence cumulée donnée.
quantile(ToothGrowth[,1], 0.025)
#On a ici la valeur pour laquelle 2.5% de la distribution est atteinte.

#Pour les variables qualitative (facteur), on peut avoir une idée de leur distribution grâce à table
table(ToothGrowth[,2])

#summary permet d'avoir une idée de la variabilité, variable par variable en fonction de son type
summary(ToothGrowth)

#Une fonction sympathique pour aller plus vite...
tapply(ToothGrowth$len, ToothGrowth$supp, summary)
#que fait tapply

####Importer un jeu de données, le modifier, et le sauvegarder
####Faire des graphiques simples
#Q12. créez un répertoire que vous appelerez stat et un sous-répertoire data dans votre
# répertoire personnel. Attention R est sensible à la capitalisation des caractères.
# téléchargez le fichier "turtle.tsv" dans le sous-répertoire data
# Ouvrez ce jeu de données dans le tableur (libreoffice Calc).
# Ouvrez ce jeu de données dans un éditeur de texte
# Le séparateur de champ correspond à la manière dont sont séparés les différents champs dans ce jeu de données. 
# Quel est il dans ce jeu de données?
#Il s'agit ici d'un séparateur tabulation

# Regardez les propriétés de de ce jeu de donnée à l'aide de la souris et de l'alinéa propriété. A l'aide de cet outil, notez l'emplacement du fichier dans l'arborescence de fichier

# Lancez R, pour cela tapez R dans l'émulateur de terminal, puis entrée.

##Naviguer dans l'arborescence de fichier depuis R.

#Afin de charger un fichier dans R et de le manipuler, il faut d'abord savoir quel est le répertoire actuel dans lequel R va chercher des données et le modifer.
# Pour vérifier le répertoire courant depuis R
getwd()
#list.files() permet de lister les fichiers dans le répertoire courant
list.files()
#setwd() permet de modifer le répertoire, il faut alors indiquer le chemin jusqu'au répertoire cible depuis le répertoire courant
setwd("stat") # permet d'entrer dansle répertoire stat depuis le répertoire courant
list.files()
setwd("data")
#pour entrer dans un répertoire d'ordre inférieur on utilise ".."
setwd("..")
getwd()
setwd("..")
getwd()
#il est possible d'indiquer le chemin complet pour atteindre le répertoire d'intérêt
setwd("stat/data")
#On l'aura compris setwd("../..") permet de monter de deux niveau d'organisation dans l'arborescence de fichiers.
#Notez bien que dans windows les / sont remplacés par des \, si vous utilisez windows, vous ne pourrez pas faire un simple copier/coller des chemins vers les fichiers mais il faudra changer les \ par des / pour qu'ils soient lus dans R

# Chargez les données grâce aux commandes suivantes

read.table(file="turle.tsv",sep="\t",dec=",",header=T)
#le jeu de données s'affiche dans la console, mais on ne peut rien en
# faire...
d <- read.table(file="turtle.tsv",sep="\t",dec=",",header=T)
    # file   -> le chemin vers le fichier, entre guillemets
    # sep    -> le séparateur de champ
    # dec    -> le séparateur décimal
    # header -> y-a-t-il des en-têtes de colonnes dans le fichier ? (vrai ou faux)

#le jeu de données ne s'affiche plus, mais il est stocké dans l'objet d
#on peut ensuite en exploiter le contenu
edit(d)

#si on veut changer des valeurs dans le tableau il faudra alors taper la commande d<-edit(d)
#On peut aussi effectuer les changements voulus aux endroits voulu grâce à l'indexation et l'assignation.
#N'oubliez pas de quitter l'éditeur de données pour retourner dans R.

#Q13.
#Quelques erreurs classiques dans le chargement...
d <- read.table(file="turtle.tvs",sep="\t",dec=",",header=T)
     ### Q. Pourquoi cette commande est-elle impropre ?
#mauvais nom de fichier (attention dans windows on ne voit pas toujours les extensions)
d <- read.table(file="turtle.tsv",sep=" ",dec=",",header=T)
     ### Q. Pourquoi cette commande est-elle impropre ?
#mauvais séparateur
d <- read.table(file="turtle.tsv",sep="\t",dec=",",header=F)
     ### Q. Pourquoi cette commande est-elle impropre ?
#l'entête n'est pas renseigné, les vecteurs seront tous de mode caractères car on va mélanger des valeurs avec des chaînes de caractères
# En conclusion: toujours commencer par vérifier que le jeu de données
# est correctement chargé
# Ensuite, vérifier que que les variables (contenu des colonnes) ont le type
# qu'elles doivent avoir ! et que la dimension de la matrice des données
# est la bonne («  de colonnes et de lignes »)

# il suffit pour cela de cliquer sur le nom de colonne dans la fenêtre
# créée par la fonction edit

# ou bien de d'interroger R sur d
#dimensions du tableau
nrow(d)
ncol(d)
dim(d)

#contenu du tableau
str(d)

#On constate que la première colonne qui devrait être une catégorie est un vecteur, on se propose donc d'en faire un facteur
d[,1]<-as.factor(d[,1])
str(d)

# NB une des rares choses qui dépend de la machine et du système d'exploitation
# sur lequel R est installé c'est la façon d'indiquer le chemin vers un fichier.
# Dans ce qui précède, R va chercher le fichier beak_size dans le
# répertoire courant
# Si jamais le fichier en question était dans un répertoire appelé stat
# dans mon répertoire personnel, ça donnerait
d <- read.table(file="~/stat/data/turtle.tsv",sep="\t",dec=",",header=T)
# sous Linux
d <- read.table(file="c:/Mes\ Documents/stat/data/turtle.tsv",sep="\t",dec=",",header=T) 
# ou quelque chose comme ça sous windoze

# R peut aussi lire directement des fichiers excel, openoffice ou bien
# aller interroger des bases de données Access ou SQL.
# Personnellement je déconseille les deux premières fonctionnalités,
# sources de nombreux ennuis à cause des fonctions
# de formatage automatique qui existent dans la plupart des tableurs.

#write.table permet d'écrire un jeu de données et de le sauvegarder dans votre ordinateur.
#Ici on va sélectionner uniquement les valeurs des mâles pour les stocker dans un nouveau fichier "male.tsv".
#Le fichier sera stocké dans le répertoire courant actuel, puisqu'aucun chemin n'est détaillé dans la commande.
#Notez ici qu'on va choisir un séparateur de champ type tabulation. Il faut absolument éviter que le séparateur de champ serve à quelque chose d'autre pour pouvoir facilement ouvrir le fichier.
write.table(d[d$sex=="m",], file="male.tsv", sep="\t")

#Quelques graphiques simples

###pour représenter des variables de type catégoriques, on utilise les graphiques en barres (barplot) ou bien en camembert (pie)
pie(table(d$sex))
barplot(table(d$sex))
#Q14. Dans ces graphiques, modifiez la couleur des barres ou des portions pour les mâles et les femelles (pour cela consultez l'aide en ligne de pie et barplot), n'hésitez pas à consulter les exemples pour vous donner des idées.
barplot(table(d$sex), col=c("pink", "blue"))

###Histogrammes pour les variables quantitatives
#Représentation de l'histogramme pour la longueur de la carapace.
hist(d$len)
#Notez qu'il est possible de créer vous même votre découpage de classe (voir l'aide en ligne). Par défaut le découpage est fait de sorte qu'il soit joli à regarder (en terme de bornes inférieures et supérieures pour les classes et en termes de nombre de barres d'histogramme).
#On peut grâce à cela représentez sur le même graphique le découpage pour les mâle et les femelles.
#dans un premier temps on représente tout, mais on va assigner les valeurs produites par la fonction pour ensuite conserver le même découpage et superposer le graphique des mâles sur le précédent. Par différences on trouvera les fréquences des femelles.
HH<-hist(d$len, col="pink")
names(HH)
HH$breaks
hist(d$len[d$sex=="m"], col="blue", breaks=HH$breaks, add=T)

#Plus compliqué mais en utilisant une combinaison de hist et barplot

h1 <- hist(d$len[d$sex=="m"],breaks=HH$breaks,plot=F)
h2 <- hist(d$len[d$sex=="f"],breaks=HH$breaks,plot=F)
barplot(rbind(h1$counts,h2$counts),beside=T,col=c("blue","pink"),names.arg=h1$mids,xlab="taille des tortues",ylab="nombre")
legend("topleft",legend=c("mâles","femelles"),fill=c("blue","pink"), bty="n")

#Graphiques type Boîtes à moustache. 
#Quand on compare une variable qualitative à une variable quantitaive il est d'usage de réaliser des graphiques type boîtes à moustaches.
boxplot(d$len~d$sex)
#ou
plot(d$len~d$sex)
#Le graphique type boite à moutache représente la valeur médiane, l'espace interquartile, le minimum et le maximum, sauf si ces valeurs sont plus extrêmes que le quartile inférieur ou supérieur -/+ 1.5 fois l'espace interquartile. Dans ce cas, alors elles apparaissent comme des points isolés, et la valeur la plus extrême de la barre fine s'arrête au maximum ou minimum en ignorant ces valeurs. Notez l'utlisation de l'opérateur de formule ~ qui veut dire en fonction de. Il est là aussi possible d'habiller le graphique avec de la couleur.
 plot(d$len~d$sex, col=c("pink", "blue"))
#Par défaut, les couleurs correspondent à l'ordre des niveaux (par ordre alphabétique f est avant m).

#Graphiques bivariés
plot(d$width~d$len)
#en utilisant l'opérateur de formule, la valeur à gauche de ~ correspond aux ordonnées, celle qui est à droite aux abscisses.
pairs(d[,2:4])
#Q15. Que fait la fonction pairs ?
#Elle permet d'obtenir sur une meme fenetre graphique toutes les combinaison de graphique bivariés à partir des colonnes séléctionnées dans le jeu de données d
##Interagir avec la fenêtre graphique
identify(d$width~d$len)
#identify permet de savoir à quelle observation correspond quel point. La fonction locator(), utilisée telle quelle permet en cliquant sur le graphique de connaître les coordonnées en abscisse et en ordonnées.

#La forme des symboles, la couleur des points et leur tailles peuvent être changées, pour cela il faut alors spécifier, pour chaque observation quelles en seront les caractéristiques. On utilise pour cela l'indexation factorielle. Par exemple si on veut obenir un vecteur de couleur correspondant au genre des tortues, on fait:

c("pink", "blue")[d$sex]

#Dans le graphique on peut ainsi modifier la couleur des symboles en fonction.
plot(d$width~d$len, col=("pink", "blue")[d$sex])

#La taille des points, leur forme sont obenues respectivement avec les arguments cex et pch. Il existe 25 symboles, les 5 derniers peuvent être rempli de couleur en spécifiant l'argument bg
plot(1:25, 1:25, pch=1:25, bg="blue")

#Q16. Constuire le graphique de la largeur en fonction de la longueur, en utilisant deux symboles dont le fond peut être coloré en fonction des deux sexes, une taille de symbole unique équivalent à la valeur 2, et deux couleurs distinctes pour le fond en fonction du sexe également.
plot(d$width~d$len, pch=c(21,22)[d$sex], bg=("pink", "blue")[d$sex],cex=2)

#Les paramètres graphiques peuvent être modifiés facilement grâce à la fonction par. 
par(bg="yellow")
par(bg="yellow", col.lab="red")
plot(1:25, 1:25, pch=1:25, bg="blue")
#Pour revenir aux paramètres par défaut il suffit de fermer la fenêtre graphique.
dev.off()
plot(1:25, 1:25, pch=1:25, bg="blue")

#Voir ?par pour tout ce qui est offert via cette fonction  

####Sauvegarder un graphique

dev.off()
png(file="symbolesR.png")
plot(1:25, 1:25, pch=1:25, bg="blue", main="Les symboles dans R")
dev.off()
# L'appel à png fait que les commandes graphiques seront exécutées dans
# un fichier et non pas dans une fenêtre.
# La commande dev.off est fondamentale: elle permet de fermer le fichier
# une fois que l'on a terminé d'afficher le graphique.
# Si on l'oublie, les commandes graphiques suivantes seront elles aussi
# exécutées dans le fichier png, en se superposant au premier graphique.
# Il est possible de sauver le graphique en jpeg en utilisant jpeg, ou 
# mieux en vectoriel en utilisant ps; dans ce cas le fichier sera sauver
# en postscript 

###########################################
#Générer des données régulières ou aléatoires dans R ####
###########################################
## Construction d'un vecteur dont le contenu suit une certaine régularité
v <- rep(1,10)
v
v <- 1:10
v
v <- seq(1,10,by=2)
v
v <- seq(1,10,length=15)
v
#Q17, que font rep et seq ?
#rep répéte un vecteur un nombre de fois donné
#sex permet de faire une séquence régulière soit par incrément régulier (by), soit par pas régulier en spécifiant le nombre de pas entre le début et la fin de la séquence.
##rééchantillonage
sample(v)
#réchantillonage avec remise
sample(v, replace=T)

# construction d'un vecteur de nombres aléatoires suivant la loi normale
v <- rnorm(100,mean=1,sd=0.1)
### Q.18. Exécutez cette fonction plusieurs fois et comparez le
       # résultat. Que se passe-t-il ?
#Le résultat change à chaque éxécution, mais la moyenne de l'échantillon et son écart type est constant (à l'erreur d'échantillonage prêt)
v <- rbinom(100,size=100,p=0.5)
# de nombreuses autres distributions sont implémentées dans R...
# bien pratique quand on veut faire des simulations

# La fonction de répartition, la fonction quantile et la fonction densité sont des fonctions amies des fonctions produisant des données aléatoires commençant en rbinom, rnorm, runnif...
#calcul de la fréquence cumulée pour un quantile donné
#loi normale
pnorm(1.645, 0,1)
#loi de student
pt(1.645, 30)
#calcul du quantile à partir de la fréquence cumulée
#loi normale
qnorm(0.95, 0,1)
#loi de student
qt(0.95, 30)

#######################################################################
#Création d'une fonction et intervalles de confiances sur la moyenne###
#######################################################################

#Nous allons créer une fonction permettant d'obtenir l'estimateur de l'erreur type sur la moyenne et l'appliquer pour notre jeu de données
#L'erreur type est définie comme le ratio entre l'estimateur de l'écart type et la racine carré de l'échantillonage.
#Notre fonction prendra donc comme unique argument un vecteur de données qui correspondra à l'argument x. Entre les accolades, il faudra préciser l'ensemble des opérations sur cet argument. Notez ici l'utilisation de sqrt pour obtenir la racine carrée. Il est recommandé d'écrire la fonction sur plusieurs lignes, et ensuite de la copier et la coller depuis sa déclaration jusqu'à la fermeture de l'accolade dans la console R pour qu'elle puisse être mise en mémoire dans la session en cours.

typeerror<-function(x)
{n<-length(x)
sdx<-sd(x)
sdx/sqrt(n)
}

typeerror
mode(typeerror)
#typeerror est donc maintenant une fonction qui calculera l'erreur standard sur un échantillon représenté par un vecteur de données. Il est possible donc de l'appliquer sur nos données.

#calcul de l'erreur standard pour la taille de l'ensemble des tortues
typeerror(d$len)
#A partir de là il est possible de calculer facilement l'intervalle de confiance pour la moyenne taille sur l'ensemble des tortues (il y a 48 tortues, donc on cherchera les quantiles de la distribution de students à 48-1 degrées de liberté).
mean(d$len)+qt(0.025, 47)*typeerror(d$len)
mean(d$len)+qt(0.975, 47)*typeerror(d$len)

#Q19. Calculez les intervalles de confiances pour la moyenne des mâles et les femelles, comparez les résultats obtenus au boxplot de la taille en fonction du sexe.
mean(d$len[d$sex=="m"])+qt(0.025, 23)*typeerror(d$len[d$sex=="m"])
mean(d$len[d$sex=="m"])+qt(0.975, 23)*typeerror(d$len[d$sex=="m"])
mean(d$len[d$sex=="f"])+qt(0.025, 23)*typeerror(d$len[d$sex=="f"])
mean(d$len[d$sex=="f"])+qt(0.975, 23)*typeerror(d$len[d$sex=="f"])
####Réalisation d'une boucle: estimation de l'intervalle de confiance par bootstrap###
#Le bootstrap est une technique de rééchantillonage avec remise permettant d'avoir une idée de l'erreur d'échantillonage associée à un paramètre. Ici nous allons utiliser les données pour rééchantilloner avec remise et recalculer le paramètre voulu sur l'échantillon 1000 fois (ici la moyenne).
mean(d$len)
M1<-mean(sample(d$len, replace=T))
M2<-mean(sample(d$len, replace=T))
#Comparez les deux valeurs
#A l'aide d'une boule nous allons stocké dans l'objet Moyb, le résultat de ce calcul pour 1000 rééchantillonage
Moyb<-NULL
#Dans un premier temps, on déclare l'objet Moyb dans lequel seront stockées les données, on lui donne une taille et une valeur inexistante, mais on on le nomme pour éviter un message d'erreur
for (i in 1:1000)
{Moyb[i]<-mean(sample(d$len, replace=T))}
#Q20. Que ce passe -t-il à chaque tour de boucle ?
#A chaque tour de boucle i est passe à l'élément suivant dans le vecteur 1 à 1000, ainsi Moyb[i] va stocké une moyenne à partir d'un rééchantillonage avec remise dans d$len de même taille que d$len
#Q21. Dessinez l'histogramme de Moyb, calculez son quantile à 2.5 et 97.5%. Le comparer avec l'intervalle de confiance obtenu précédemment. A l'aide de la fonction abline tracez un trait vertical rouge sur l'histogramme correspondant à chaque quantile. 
hist(Moyb)

q025<-quantile(Moyb, 0.025)
q975<-quantile(Moyb, 0.975)
abline(v=q025)
abline(v=q975)