###################################################
#																								  #
# 			 CORRECTION DE LA FEUILLE DE TD1		      #
#																								  #
###################################################



######## Attention, il faut prendre l'habitude depuis le debut de :
######## 1/ Taper dans l'editeur de texte et de copier coller, vous y gagnerez du temps !!!!
######## 2/ Enregistrer regulierement, si R se plante et que vous n'avez pas sauve vous perdrez tout.
######## 3/ Prenez l'habitude de commenter les programmes avec des # pour savoir ce que vous faites et en particulier de 
########    marquer les numeros des questions.
########		C'est sur un fichier de ce type que vous serez evalues. Il faut qu'il puisse tourner sans que le 
########		correcteur ait a choisir les bouts interessants.
######## 4/ Envoyez vous le fichier par email a la fin de la seance pour le conserver. C'est ainsi que vous pourrez 
########		reutiliser facilement les saisies d'une fois a l'autre (vous n'aurez pas toujours le meme ordinateur 
########		et les autres etudiants qui seront passes sur la machine peuvent aussi effacer votre fichier)
######## 		Le jour du controle sur machine, c'est aussi ainsi que vous communiquerez avec l'enseignant.
######## 5/ Le fait de savoir deja suivre ces 5 points et etre capable de le faire correctement le jour de l'examen, fait 
########    partie de l'apprentissage. Nous ne ferons rien pour vous aider a retrouver vos saisies et a nous les 
########		envoyer a la fin de  l'examen.  









# ---------------- 1. Ouverture du logiciel R et utilisation d'un script ----------------

# 1/ a)b)c)d)

a=2


# 1/ e)f)g)

# Il ne se passe rien visuellement on a juste copie colle la ligne. 
# Le fait d'avoir tape 'entree' a par contre cree la variable et mis dans la variable a, la valeur 2


# 1/ h)

# On voit qu'il a mis 2 dans la variable a, puisqu'il nous donne ce qui est dans a.


# 1/ i)

# Comme on n'a pas defini b, il ne le trouve pas.


# 1/ j)k)

getwd()
# Il renvoie la ou on est dans l'arborescence des fichiers, cad dans quel dossier on se trouve

# 1/ l)

setwd('C:/Users/Etudiant/Desktop/votrenom')


# 1/ m)

getwd()
# setwd() a change l'endroit ou on se trouve maintenant.


# 1/ n)

a
# On a beau etre dans le bon repertoire, il ne sait pas qui est a car on a pas execute le script


# 1/ o)

# Attention de ne pas faire quelque chose de recursif dans les appels : ce n'est pas bon qu'un fichier s'appelle soi-meme, il y aura sinon un message d'erreur. Il faut arreter le fichier ici sans le source puis taper la ligne ci dessous uniquement dans la console :
source('correction_td1.txt')


# 1/ p)q)r)

a
# Maintenant il sait que a existe et vaut 2









# ---------------- 2. Premieres commandes avec R ----------------

# 2 /a)

c(1,2,6,3)
# Il cree un vecteur de taille 4, comme on ne lui a pas donne de nom de variable, il le renvoie. La commande c() cree des vecteurs.


# 2/ b)

seq(1,7,2)
seq(-2,9.5,3.5)
# Il cree un vecteur de taille 4. seq(a,b,d) cree un vecteur regulierement espace qui part de a et avance par pas de d jusqu'au plus grand nombre inferieur a b.


# 2/ c)

rep(c(1,2,3),3)
# Il prend le vecteur 1 2 3 et le copie 3 fois bout a bout dans un grand vecteur de taille 3*3=9


# 2/ d)

rep(c(1,2,3),each=3)
# Il copie individuellement chaque nombre du vecteur 1 2 3, 3 fois avant de passer au chiffre d'apres.


# 2/ e)

x=c(1,3,6,2)
x[2]
# Il renvoie le deuxieme coefficient du vecteur x que l'on a defini avant
# Attention : contrairement a certains langages de programmation, en R le premier indice est en position 1 (et non 0)


# 2/ f)

x[-2]
# Il renvoie le vecteur x prive de son deuxieme coefficient


# 2/ g)

which(x==2)
# Il renvoie les indices ou il y a la valeur 2 dans x
# (testez avec un x qui contiendrait plusieurs fois la valeur 2)


# 2/ h)

vector("numeric",length=4)
# Il renvoie un vecteur nul de taille 4, ici rempli de nombres (numeric) et par defaut mis a 0
# On peut aussi faire : numeric(4)


# 2/ i)

y=sort(x)
y
# sort range le vecteur par ordre croissant


# 2/ j)

z=sort(x,index.return=TRUE)
z
z$x
z$ix
# z est une liste de deux vecteurs :
#   - le premier nomme z$x est le vecteur range
#   - le deuxieme z$ix est le vecteur des indices du vecteur x initial
# On aurait egalement pu extraire ces deux vecteurs avec les commandes z[['x']] et z[['ix']]









# ---------------- 3. Premiers exercices ----------------

# 3/ a)

b=seq(6,144,2)


#3/ b) 

# NB ne pas utiliser la lettre c comme nom de variable a cause de la confusion avec la commande c()
d=seq(7,144,2)


#3/ c)

e=c(b,d)
# On peut coller des vecteurs avec juste c()


# 3/ d)

f=e[-c(7,24)]
# On peut enlever plusieurs indices en une fois du moment qu'on en fait un vecteur


# 3/ e)

ind44=which(f==44) # la ou est le 44 dans b
ind76=which(f==76) # la ou est 76 dans b
g=f[-c(ind44,ind76)] # on enleve ces deux indices. NB on a au milieu du creer le vecteur des indices a enlever


# 3/ f)

x=1:100
x%%3
# 1:100 donne le vecteur des entiers de 1 a 100. a%%b donne le "modulo", cad le reste de la division euclidienne de a par b, par exemple 14=3*4 + 2, le reste vaut 2









# ---------------- 4. Autres objets avec R ----------------

# 4/ a)i.

x=c(rep(c(1,2),3),rep(c(1,4),5))
h=factor(1:3)
x+1
h+1
# Un facteur est un "label" on ne peut pas faire d'operation arithmetique dessus
# Meme si on a mis des nombres dedans, R ne les interprete pas comme tels.
# Tester is.numeric(h)
# Remarque : un vecteur peut contenir autre chose que des valeurs numeriques. Exemple :
# vec=c("chien", "chat")
# Dans ce cas la l'operation vec+1 ne fonctionne plus...


# 4/ a)ii.

is.factor(x)
is.factor(h)
is.vector(x)
is.vector(h)
# Permet de tester si on est ou pas un facteur ou un vecteur


# 4/ a)iii.

xf=as.factor(x)
is.vector(xf)
is.factor(xf)
# Transformation de vecteur en facteur


# 4/a)iv.

# is. verifie, as. transforme


# 4/a)v.

summary(x)
summary(xf)
# Si l'objet est un vecteur, summary en donne les statistiques principales en tant que variable quantitative (min, 1er quartile, mediane, 3eme quartile, maximum). Si il est un facteur, summary en donne les statistiques principales en tant que variable qualitative (table de contingence)


# 4/ a)vi.

j=factor(1:3,levels=1:4)
summary(j)
summary(h)
# Permet de savoir qu'il y a une 4eme modalite possibe qui est juste absente du facteur. Cela modifie donc la table de contingence.


#4/b)i.

A=matrix(1:10,nrow=2)
B=matrix(1:10,nrow=2,byrow=TRUE)
# Il cree une matrice. Premier cas (par defaut) : remplissage colonne par colonne. Deuxieme cas : remplissage ligne par ligne


# 4/b)ii.
A[,4]
A[2,]
# Extrait la 4eme colonne ou la 2eme ligne


# 4/ b) iii.

C=A[,-2]
# On cree une matrice a partir de A dont on a retire la deuxieme colonne


# 4/ b) iv.

A[-1,]
# Premiere ligne enlevee. Comme il ne reste qu'une seule ligne ca devient un vecteur


# 4/ b) v.

cbind(A,B)
rbind(A,B)
# On fait une grande matrice ou les colonnes sont collees (cbind) ou bien les lignes sont collees (rbind)


# 4/ b) vi.

A=matrix(1:4,ncol=2)
B=matrix(c(1,3,8,4),ncol=2)
t(A) # transposee de A
solve(A) # inverse de A
A*B # produit terme a terme
A%*%B # produit matriciel


# 4/ c) i.

u=c(1,3) # vecteur
v=list(1,3) # liste


# 4/ c) ii.

v[[1]] # renvoie le premier element de la liste v
# Attention v[1] ne renverrait pas le premier element de v mais une sous-liste de v
# Tester is.list(v[1])
# v[[1]]+47 fonctionnerrait mais pas v[1]+47


# 4/ c) iii.

u=c(x,xf)
# On voulait obtenir le vecteur 1 2 1 2 1 2 1 4 1 4 1 4 1 4 1 4 1 2 1 2 1 2 1 4 1 4 1 4 1 4 1 4 mais cette commande renvoie le vecteur 1 2 1 2 1 2 1 4 1 4 1 4 1 4 1 4 1 2 1 2 1 2 1 3 1 3 1 3 1 3 1 3.
# Explication : le probleme vient de la conversion facteur->vecteur
# Exemple : ff=factor(c("rouge", "vert", "bleu", "rouge"))
# Si on essaie de convertir ff en vecteur avec la commande c(ff), cela renvoie 2 3 1 2. R remplace chaque element du facteur par sa position dans la liste des niveaux ("bleu" est en position 1, "rouge" en position 2, et "vert" en position 3)
# Par contre as.vector(ff) renvoie bien le vecteur "rouge" "vert"  "bleu"  "rouge"
# Pour xf, si nous voulons obtenir un vecteur de nature numerique apres sa conversion, il nous faut de plus utiliser la commande as.numeric
# La commande correcte etait donc u=c(x,as.numeric(as.vector(xf)))

is.vector(u)
# On perd le fait que xf est un facteur

v=list(x,xf)
is.vector(v[[1]])
is.factor(v[[2]])
# Cela cree une liste dont le premier element est un vecteur et le deuxieme un facteur
# L'interet de la liste est donc de pouvoir melanger dans une meme structure des elements de type differents


#4/c) iv.

sample(1:10,3)
sample(1:10,3,replace=TRUE)
help(sample)
# sample tire aleatoirement (sans ou avec remise) 3 chiffres dans le vecteur 1:10


# 4/ c) v.

el1=list(monvec=c(1:10),monfac=factor(sample(1:3,10, replace=TRUE)),mamat=matrix(1:10,ncol=5))
el2=list(c(1:10),factor(sample(1:3,10,replace=TRUE)),matrix(1:10,ncol=5))

el1[[2]]
el1$monfac
# Ces deux commandes extraient le deuxieme element de la liste, mais avec el1, on a donne un nom aux elements de la liste, donc on n'est pas oblige de se souveir de l'ordre et les sorties sont plus lisibles


#4/ c) vi.

el3=list(1:10,1:4,1:7) # liste de 3 vecteurs
el4=list(1:10,list(1:4,1:7)) # liste de 1 vecteur et d'une liste de deux vecteurs


#4/c) vii.

el4[[2]][[2]]


#4/d)i.

data.frame(1:10,LETTERS[1:10])
# Produit un objet a deux colonnes: 1ere les 10 premiers chiffres, 2eme les 10 premieres lettres


#4/d) ii.

U1=data.frame(x=1:10,y=LETTERS[1:10])
# Les noms des colonnes ont change. C'est maintenant x et y


#4/d) iii.

U2=matrix(c(1:10,LETTERS[1:10]),ncol=2)

is.vector(U1[,1])
U1[,1]+1
is.factor(U1[,2])

is.factor(U2[,1])
is.vector(U2[,1])
U2[,1]+1

U2[1,,drop=FALSE]
is.vector(U2[1,,drop=FALSE])
is.matrix(U2[1,,drop=FALSE])
as.matrix(U2[1,])

# Vu tous ces tests, la structure dataframe permet de melanger des colonnes quantitatives et qualitatives alors que faire une matrice transforme tout en donnees qualitatives car les lettres ne peuvent pas etre autre chose. Remarquez que l'extraction d'une colonne devient alors un vecteur si quantitatif et facteur sinon. Ca devient un vecteur quand on part d'une matrice (mais on arrive pas a faire l'addition car il ne considere plus ce qui est dedans comme un numerique). L'ajout de drop permet de conserver le statut de matrice mais avec une seule ligne ou colonne. Faire repasser la ligne qui etait devenue vecteur sans le drop a une matrice fait perdre la bonne orientation, donc attention !


# 4/ d) iv.

a=matrix(1:10,ncol=2)
A=data.frame(x=1:5,y=6:10)

a[,2]
A[,2]
# C'est la meme commande


# 4/d) v.

colnames(a)=c('x','y')
# Met des noms aux colonnes, ca ressemble beaucoup plus a A


# 4/ d) vi.

A$y # pareil que A[,2]
a$y # ne marche pas

d=matrix(c(9,0),ncol=1)
A%*%d
a%*%d  # mais le produit matriciel ne marche que pour a
as.matrix(A) # pour passer de l'un a l'autre


# 4/ e) 

aa=array(c(list()),c(2,3,2))
aa[1,1,1][[1]]=matrix(1:12,ncol=4)
aa[1,2,1][[1]]=list(c(1,3,5),LETTERS[1:3])
# Cree un tableau a 3 dimensions avec 3 indices 2 lignes, 3 colonnes, et 2 en profondeur et on peut mettre dans chaque case ce qu'on veut comme type (un peu comme les listes ici en 3d mais on peut mettre autant d'indices que l'on veut)









# ---------------- 5. Deuxiemes exercices ----------------

# 5/a)

AA=matrix(1:12,ncol=4)
BB=matrix(c(2,4,6,3,6,9,4,8,12),ncol=3)
# Ou plus astucieusement :
# a=1:3
# BB=matrix(c(a,2*a,3*a),ncol=3,byrow=TRUE)
CC=matrix(c(1,2,3,5,7,11,13,17),nrow=2)

malist=list(A1=AA,A2=BB,A3=CC)


# 5/ b)

A=matrix(c(2,1,1,3,-3,1,-1,1,1),ncol=3)
b=c(1,2,4)
# Premiere methode : utiliser la formule de maths qui donne la solution
u=solve(A)%*%b # c'est la solution du systeme
A%*%u # verification du fait que c'est bien la bonne solution
# Deuxieme methode : utiliser la fonction de resolution de R
u=solve(A,b)
# NB la premiere methode renvoie une matrice, la deuxieme un vecteur !


# 5/ c)

help(rnorm)
# rnorm renvoie un vecteur de variables gaussiennes de moyenne et ecart type donne

mesnorm=array(0,c(100,3,3)) # J'ai 3 indices : 1 pour l'echantillon, 1 pour mu et 1 pour sigma^2, d'ou un array. Je n'ai pas besoin de mettre de list dedans pour melanger les types, ce ne sont que des nombres

# ---- mu=-2 ----
# sigma^2=0.1
mesnorm[,1,1]=rnorm(100,-2,sqrt(0.1))
# sigma^2=1
mesnorm[,1,2]=rnorm(100,-2,1)
# sigma^2=4
mesnorm[,1,3]=rnorm(100,-2,2)
# ----mu=0 ----
# sigma^2=0.1
mesnorm[,2,1]=rnorm(100,0,sqrt(0.1))
# sigma^2=1
mesnorm[,2,2]=rnorm(100,0,1)
# sigma^2=4
mesnorm[,2,3]=rnorm(100,0,2)
# ---- mu=2 ----
# sigma^2=0.1
mesnorm[,3,1]=rnorm(100,2,sqrt(0.1))
# sigma^2=1
mesnorm[,3,2]=rnorm(100,2,1)
# sigma^2=4
mesnorm[,3,3]=rnorm(100,2,2)

# On aurait pu aussi le faire avec des boucles for :

mu=c(-2,0,2)
sigma=c(sqrt(0.1),1,2)

# Attention a toujours bien indenter les boucles pour voir ou on s'arrete

for (i in 1:3) # indice pour mu
{
  for (j in 1:3) # indice pour sigma
  {
    mesnorm[,i,j]=rnorm(100,mu[i],sigma[j])
  }
}


#5/ d)

R=matrix(rnorm(1000),ncol=10)
S=matrix(as.factor(floor(rnorm(1000))),ncol=10)

# On utilise un data.frame pour conserver la nature quantitative de R et la nature qualitative de S
RS=data.frame(R=R,S=S)
is.vector(RS[,1])
RS[,1]+1
is.factor(RS[,11])









# ---------------- 6. Representations graphiques de base ----------------

# 6/a)

x=seq(0,4,0.1)
y=2-3*x+rnorm(length(x))
plot(x,y)
# On trace les points d'abcisse x et ordonnee y, ici une regression lineaire bruitee


#6/b)

x=seq(-10,10,0.1)
y=dnorm(x)
plot(x,y)
plot(x,y,type='l')
# type ='l' donne une ligne et pas des points


# 6/c)

plot(x,y,type='l',lty=3)
# lty change le style du trace


# 6/ d)

plot(x,y,type='l',lwd=3)
# lwd change l'epaisseur du trait

plot(x,y,col='red')
# col change la couleur


# 6/ e)

plot(x,y,main='densite gaussienne',xlab='x', ylab='f(x)',type='l')
# main pour mettre un titre, xlab et ylab pour changer le nom des axes
legend(-8,0.3,'densite',lty=1)
# Les deux premiers arguments de legend() permettent de definir sa position sur le graphique


# 6/ f)

X11()
# Ouvre une nouvelle fenetre graphique


# 6/ g)

x=seq(0,5,0.1)
plot(x,2*x+1,type='l',col='blue')
plot(x,2.1*x^2+1,type='l',col='red')
# Fait l'un puis l'autre au meme endroit, on ne voit plus le premier

plot(x,2*x+1,type='l',col='blue')
par(new=TRUE)
plot(x,2.1*x^2+1,type='l',col='red') # plot(x,2.1*x^2+1,type='l',col='red')
# Superpose les deux (regarder l'axe des ordonnees)

plot(x,2*x+1,type='l',col='blue')
X11()
plot(x,2.1*x^2+1,type='l',col='red') # plot(x,2.1*x^2+1,type='l',col='red')
# Fait deux fenetres graphiques


# 6/ h)
plot(x,2*x+1,type='l',col='blue')
par(new=TRUE)
plot(x,12*x+1,type='l',col='red') # echelles mauvaises (cf le cote gauche, les deux droites sont alors confondues)

plot(x,2*x+1,type='l',col='blue',xlim=c(0,5),ylim=c(0,60),xlab='',ylab='')
par(new=TRUE)
plot(x,12*x+1,type='l',col='red',xlim=c(0,5),ylim=c(0,60),xlab='x',ylab='y', main='deux droites')
legend(0.5,50,c('pente 2','pente 12'),col=c('blue','red'),lty=c(1,1))
# Forcer les axes a etre les memes avec xlim et ylim


# 6/ i)

par(mfrow=c(2,3))
plot(x,-x+1)
plot(x,-2*x+1)
plot(x,3*x-1)
plot(x,-5*x+4)
plot(x,-x-1)
plot(x,-4*x+10)
# Decoupage en 2 lignes et 3 colonnes pour 6 dessins remplissage par ligne

# 6/ j)

par(mfcol=c(2,3))
plot(x,-x+1)
plot(x,-2*x+1)
plot(x,3*x-1)
plot(x,-5*x+4)
plot(x,-x-1)
plot(x,-4*x+10)
# Meme nb lignes colonnes mais remplissage par colonne








# ---------------- 7. Troisiemes exercices ----------------

# 7/ a)

lambda=c(1,2,4,5)

x=seq(0,10,0.1)
plot(x,lambda[1]*exp(-lambda[1]*x),ylim=c(0,5), type='l',col='red',ylab='')
par(new=TRUE)
plot(x,lambda[2]*exp(-lambda[2]*x),ylim=c(0,5), type='l',col='blue',ylab='')
par(new=TRUE)
plot(x,lambda[3]*exp(-lambda[3]*x),ylim=c(0,5), type='l',col='green',ylab='')
par(new=TRUE)
plot(x,lambda[4]*exp(-lambda[4]*x),ylim=c(0,5), type='l',col='magenta',ylab='f(x)',main='Densite exponntielle')
legend(6,4,c('lambda=1','lambda=2','lambda=4','lambda=5'),col=c('red','blue','green','magenta'),lty=c(1,1,1,1))


# 7/ b)

par(mfrow=c(2,2))
plot(x,lambda[1]*exp(-lambda[1]*x),ylim=c(0,5), type='l',col='red',ylab='f(x)', main=paste('lambda=',lambda[1]))
plot(x,lambda[2]*exp(-lambda[2]*x),ylim=c(0,5), type='l',col='red',ylab='f(x)', main=paste('lambda=',lambda[2]))
plot(x,lambda[3]*exp(-lambda[3]*x),ylim=c(0,5), type='l',col='red',ylab='f(x)', main=paste('lambda=',lambda[3]))
plot(x,lambda[4]*exp(-lambda[4]*x),ylim=c(0,5), type='l',col='red',ylab='f(x)', main=paste('lambda=',lambda[4]))


# 7/ c)

x=seq(0,1,0.1)
plot(x,2*x+1,xlim=c(0,3),ylim=c(0,3),xlab='',ylab='',main='',type='l')
par(new=TRUE)
x=seq(1,2,0.1)
plot(x,-x+3,xlim=c(0,3),ylim=c(0,3),xlab='',ylab='',main='',type='l')
par(new=TRUE)
x=seq(2,3,0.1)
plot(x,0*x,xlim=c(0,3),ylim=c(0,3),xlab='x',ylab='f(x)',main='trace de f', type='l')


# 7/ d)

x=seq(-1,11,2)
y=seq(0,1,0.2)
y=c(y,1) # il faut que je repete 1 une fois pour le dernier
plot(x,y,type='s', col='blue', lty=3,xaxt='n', ylab='probabilite', main='fonction de repartition')
# On enleve l'echelle naturelle de l'axe x, type ='s' fait la courbe en escalier 
axis(1,x)
# On lui met les graduations d'axe que l'on souhaite