```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE, cache = TRUE)
```


## Exercice 3.1 : Tracé d'une fonction

1. Définissons une grille de variation pour *x* puis traçons la courbe *sinus*:
```{r,message=FALSE,warning=FALSE,eval=FALSE}
x <- seq(0,2*pi,length=1000)
plot(sin(x)~x,type="l")
```
2. Pour rajouter le titre, on utilise la fonction *title* (on aurait pu directement utiliser l'argument *main*
dans la fonction *plot*):
```{r,message=FALSE,warning=FALSE}
plot(sin(x)~x,type="l")
title("Graphe de la fonction sinus")
```

## Exercice 3.2 : Comparaison de distributions

1. Pour tracer une loi normale, il suffit de tracer la densité en utilisant la fonction *dnorm*. On peut ensuite
améliorer le graphique en traçant l'axe des abscisses puis un segment entre 0 et le maximum de la loi normale:
```{r,message=FALSE,warning=FALSE,eval=FALSE}
plot(dnorm,-4,4)
abline(h=0)
segments(0,0,0,dnorm(0),lty=2)
```
2. Pour tracer de nouvelles courbes nous utilisons la fonction *curve* avec l'argument *add=TRUE*.
Pour différencier les courbes, on utilise une couleur différentes pour chaque distribution.
```{r,eval=FALSE}
curve(dt(x,5),add=TRUE,col=2)
curve(dt(x,30),add=TRUE,col=3)
```
3. Il suffit d'utiliser la fonction *legend* et de la positionner en haut à gauche:
```{r,message=FALSE,warning=FALSE}
plot(dnorm,-4,4)
abline(h=0)
segments(0,0,0,dnorm(0),lty=2)
curve(dt(x,5),add=TRUE,col=2)
curve(dt(x,30),add=TRUE,col=3)
legend("topleft",legend=c("normale","Student(5)","Student(30)"),
    col=1:3,lty=1)
```

## Exercice 3.3 : Tracé de points

1. L'importation et la construction du nuage de points sont immédiates:
```{r,message=FALSE,warning=FALSE,eval=FALSE}
ozone <- read.table("https://r-stat-sc-donnees.github.io/ozone.txt",header=TRUE)
plot(maxO3~T12,data=ozone)
```
2. Pour relier les points, il suffit d'utiliser l'argument *type="l"*; ce graphe n'est pas lisible car il faut préalablement trier
les données par abscisses croissantes.
3. C'est ce que permet la
fonction *order*:
```{r,message=FALSE,warning=FALSE}
ordon <- order(ozone[,"T12"])
plot(maxO3~T12,data=ozone[ordon,],type="b")
```

## Exercice 3.4 : Loi des grands nombres

1. On crée un vecteur $X$ de longueur 1000:
```{r,message=FALSE,warning=FALSE}
set.seed(123)
X <- rbinom(1000, size=1, prob=0.6)
```
2. La fonction *cumsum* permet de construire un vecteur de sommes cumulées:
```{r,message=FALSE,warning=FALSE}
Sl <- cumsum(X)
Ml <- Sl/(1:1000)
plot(Ml, type="l")
abline(h=0.6, col=2)
```
Le graphique obtenu illustre la loi des grands nombres.

## Exercice 3.5 : Théorème central limite

1.  S_N suit une loi binomiale de paramètres *N* et *p*, de moyenne *N * p* et d'écart-type *racine(N*p/(1-p)*.
2. On fixe la graine du générateur aléatoire avant de simuler un vecteur de 1000 réalisations d'une loi binomiale de paramètres *N* et *p* :

```{r,message=FALSE,warning=FALSE}
set.seed(123)
p <- 0.5
N <- 10
U10 <- (rbinom(1000, size = N, p=p) - N*p) /sqrt(N*p*(1-p))
N <- 30
U30 <- (rbinom(1000, size = N, p=p) - N*p) /sqrt(N*p*(1-p))
N <- 1000
U1000 <- (rbinom(1000, size = N, p=p) - N*p)/sqrt(N*p*(1-p))
```

3. Afin de dessiner la courbe de la loi normale centrée-réduite, on crée une grille de $x$ variant entre -4 et 4. On découpe alors la fenêtre graphique en 1 ligne et 3 colonnes puis on trace un histogramme et on superpose la courbe de la loi normale.

```{r,message=FALSE,warning=FALSE}
grillex <- seq(-4, 4, by = 0.01)
par(mfrow=c(1,3))
hist(U10, xlim=c(-4,4), ylim=c(0,0.6), prob=TRUE)
lines(grillex, dnorm(grillex), col=4)
hist(U30, xlim=c(-4,4), ylim=c(0,0.6), prob=TRUE)
lines(grillex, dnorm(grillex), col=4)
hist(U1000, xlim=c(-4,4), ylim=c(0,0.6), prob=TRUE)
lines(grillex, dnorm(grillex), col=4)
```

## Exercice 3.6 : Tracé des taches solaires

1. Le séparateur de décimale est ici la virgule, ce qu'il est important de préciser, sinon la
variable *nbe_tach* est considérée comme qualitative.
```{r,message=FALSE,warning=FALSE}
taches<-read.table("https://r-stat-sc-donnees.github.io/taches_solaires_date.csv",sep=";",header=TRUE,
     colClasses=c("numeric","Date"))
summary(taches)
```

2. Créons la variable qualitative trenteans:
```{r,message=FALSE,warning=FALSE}
trenteans <- cut(taches[,2],breaks="30 years")
levels(trenteans) <- 1:nlevels(trenteans)
```
3. Vérifions que les couleurs citées appartiennent bien à la palette de couleur
```{r,message=FALSE,warning=FALSE}
couleurs<-c("yellow","magenta","orange","cyan","grey","red",
    "green","blue")
all(couleurs%in%colors())
```
4. Pour tracer la série chronologique de la figure, on construit d'abord le graphe sans courbe et sans point (argument *type="n"*)
ce qui permet de définir les plages de variation de *x* et *y* ainsi que les libellés des axes. On dessine alors les morceaux de courbe un par un
en changeant de couleur à chaque modalité de *trenteans*:
```{r,message=FALSE,warning=FALSE}
palette(couleurs)
coordx <- seq(along=taches[,1])
plot(coordx,taches[,1],xlab="Temps",ylab="Nb de taches",type="n")
for (i in levels(trenteans)){
  selecti <- trenteans==i
  lines(coordx[selecti],taches[selecti,1],col=i)
}
```

## Exercice 3.7 : Tracé d'une densité

1. Pour tracer la courbe de la loi normale, on définit d'abord l'intervalle de variation de *x*:

```{r,message=FALSE,warning=FALSE,eval=FALSE}
x <- seq(-3.5,3.5,length=1000)
plot(x,dnorm(x),type="l",ylab="Densité")
```

2. Pour tracer une droite horizontale, on utilise *abline* et l'argument *h*:
```{r,message=FALSE,warning=FALSE,eval=FALSE}
abline(h=0)
```
3. à 5. Pour les questions 3 à 5, on utilise les fonctions *polygon*, *arrows* et *text*.
Pour pouvoir écrire des mathématiques
avec la fonction *text*, on utilise *expression*:
```{r,message=FALSE,warning=FALSE}
x <- seq(-3.5,3.5,length=1000)
plot(x,dnorm(x),type="l",ylab="Densité")
abline(h=0)
selecti <- x>=qnorm(0.95)
absci <- c(x[selecti],rev(x[selecti]))
ordon <- c(rep(0,sum(selecti)),rev(dnorm(x[selecti])))
polygon(absci,ordon,col="blue")
arrows(2.7,0.2,2,dnorm(2),len=0.1)
text(2.7,0.2,expression(paste(alpha==5,"%")),pos=3)
```

## Exercice 3.8 : Plusieurs graphiques

1. Pour générer le graphique, on est amené à redéfinir les marges de chaque graphique à l'aide de la fonction *par*. On utilise
également la fonction *layout* pour définir la disposition des trois graphiques:
```{r,message=FALSE,warning=FALSE}
par(mar=c(2.3,2,0.5,0.3))
layout(matrix(c(1,1,2,3), 2, 2, byrow = TRUE))
plot(1:10,10:1,pch=0)
plot(rep(1,4),type="l")
plot(c(2,3,-1,0),type="b")
```
2. L'argument *widths* de *layout* permet de préciser la largeur de chaque colonne:
```{r,message=FALSE,warning=FALSE}
par(mar=c(2.3,2,0.5,0.3))
layout(matrix(c(1,1,2,3), 2, 2, byrow = TRUE),widths=c(4,1))
plot(1:10,10:1,pch=0)
plot(rep(1,4),type="l")
plot(c(2,3,-1,0),type="b")
```

## Exercice 3.9 : Nombre d'étudiants par ville universitaire

1. L'importation avec séparateur *;* la classe et le résumé sont donnés par:
```{r,message=FALSE,warning=FALSE}
villes <- read.table("https://r-stat-sc-donnees.github.io/villes.csv",header=TRUE,sep=";")
class(villes)
summary(villes)
```
2. Le vecteur *decoupe* est créé avec
```{r,message=FALSE,warning=FALSE}
decoupe <- c(0,15000,25000,50000,75000,100000,max(villes$Nb.etudiant))
```

3. Le découpage est obtenu avec la fonction *cut* en incluant les extrêmes:
```{r,message=FALSE,warning=FALSE}
Xq <- cut(villes$Nb.etudiant,breaks=decoupe)
```
4. Le changement des modalités est effectué par:
```{r,message=FALSE,warning=FALSE}
levels(Xq) <- paste(format(decoupe[-length(decoupe)]),
             format(decoupe[-1]),sep="-")
```
5. Après avoir chargé le package *ggmap*, la bounding box est obtenue avec
```{r,message=FALSE,warning=FALSE}
library(ggmap)
bbox <- make_bbox(longitude,latitude,data=villes)
```
6. La variable qualitative *Xq* est ajoutée à  *villes*:
```{r,message=FALSE,warning=FALSE}
villes <- cbind.data.frame(villes,Effectif=Xq)
```

7. Le téléchargement s'effectue simplement:
```{r,message=FALSE,warning=FALSE}
MaCarte <- get_map(bbox)
```

9. Le tracé est alors (en enlevant la légende automatique pour "size" avec la fonction *guides*)
```{r,message=FALSE,warning=FALSE}
ggmap(MaCarte) + geom_point(data = villes, aes(x=longitude,y=latitude,color = Effectif,size=5000*log(Nb.etudiant)))+guides(size=FALSE) 
```

## Exercice 3.10 : Chômage  et élection régionale

1. L'importation utilise la fonction *read_sf* du
  package *sf* et importe le contenu du répertoire grâce à:
```{r,message=FALSE,warning=FALSE}
library(sf)
setwd("C:/Users/husson/Dropbox/Rpourlastatetladatascience/chapitre/cartes/DONNEES")
regions <- read_sf("regions-metropole-complet")
```
2. Le graphique (pour la première variable) est simplement
```{r,message=FALSE,warning=FALSE}
plot(regions[,1])
```
3. Le résumé et la classe sont obtenues par
```{r,message=FALSE,warning=FALSE}
summary(regions)
class(regions)
```
4. Le résumé pécédent nous a affiché les noms de variables et nous pouvons lire que la variable *NOM* contient le nom des région et son contenu s'affiche bien avec
```{r,message=FALSE,warning=FALSE}
regions$NOM
```
  La première variable *NOM* donne l'intitulé de la région, la
  seconde son code.
5. Le graphique s'obtient comme suit:
```{r,message=FALSE,warning=FALSE}
plot(regions[1,1])
```
6. La région correspondante, le Limousin, est donnée par
```{r,message=FALSE,warning=FALSE}
regions$NOM[1]
```
7. Nous sélectionnons dans l'objet *regions* les lignes qui correspondent à une valeur pour la  variable *NOM* d'*Alsace* grâce à *filter* et nous traçons:
```{r,message=FALSE,warning=FALSE}
library(dplyr)
ggplot() + geom_sf(data=regions %>% filter(NOM=="Alsace"))
```
8. L'importation se fait avec *read_delim* du package *readr* qui importe directement au format *tibble*:
```{r,message=FALSE,warning=FALSE}
library(readr)
chomregion <- read_delim("https://r-stat-sc-donnees.github.io/txchom_region.csv",delim=";")
```
Nous créons une variable de type caractère *NUMERO* et supprimons la variable *CODGEO* avec:
```{r,message=FALSE,warning=FALSE}
chomregion <- mutate(chomregion, NUMERO=as.character(CODGEO),
                     CODGEO=NULL)
```

9. Nous fusionnons selon *NUMERO*:
```{r,message=FALSE,warning=FALSE}
chomtot <- inner_join(regions,chomregion,by="NUMERO")
```
10. Le graphique qui colorie par ordre décroissant (signe "-") selon le taux de chômage 2011 est obtenu avec:
```{r,message=FALSE,warning=FALSE}
ggplot() + geom_sf(data=chomtot,aes(fill=-TCHOMB1T11))
```
11. La variable *Majorite* est ajoutee au tibble *chomtot* avec
```{r,message=FALSE,warning=FALSE}
chomtot <- chomtot %>% mutate(majorite= factor(Majorite,levels=c("UMP","PRG","PS","DVG")))
```
Remarquons que les niveaux (et l'ordre) des facteurs est contrôlé avec l'argument *levels* de la fonction *factor*. Ensuite le graphique est obtenu par
```{r,message=FALSE,warning=FALSE}
ggplot() + geom_sf(data=chomtot,aes(fill=majorite)) +
  scale_fill_manual(values=c("blue","salmon","pink","pink2"))
```

## Exercice 3.11 : Représentation graphique et projection

1. Le package est chargé puis la carte est tracée avec la fonction
  *map*:
```{r,message=FALSE,warning=FALSE}
library(maps)
map("state",plot=TRUE)
```
2. L'objet de type *map* est en suite transformé en type *sfc* 
```{r,message=FALSE,warning=FALSE}
usa <- map("state",plot=FALSE,fill=TRUE)
```
3. Transformons le en sfc
```{r}
usasf <- st_as_sfc(usa)
class(usasf)
```

4. Il est ensuite représenté:
```{r,message=FALSE,warning=FALSE}
plot(usasf)
```
4. La projection en polyconique puis le graphique:
```{r,message=FALSE,warning=FALSE}
usasf2 <- st_transform(usasf,102008)
plot(usasf2)
```
## Exercice 3.12 : Représentation de tuiles
1. Trouvons les coordonnées avec la projection de Mercator (à la main):
```{r,message=FALSE,warning=FALSE}
lon <- 6.615982
lat <- 45.85161
zoom <- 13
xx <- (lon+180)/360 * 2^zoom
yy <- (1- log(tan(lat*pi/180)+1/cos(lat*pi/180)) /pi)*2^(zoom-1)
```

2. Arrondissons pour trouver *xtile* et *ytile*
```{r,message=FALSE,warning=FALSE}
xtile <- floor(xx)
ytile <- floor(yy)
```

3. Téléchargeons la tuile: 
   a. dans un premier temps composons l'URL
```{r,message=FALSE,warning=FALSE}
urlStr <- paste("https://b.tile.openstreetmap.org/",zoom,"/",xtile,"/",ytile,".png",sep="")
```
   b. dans un second temps téléchargeons l'image
```{r,message=FALSE,warning=FALSE}
download.file(urlStr,"Rochebrune.png", mode = "wb", quiet = TRUE)
```
   c. dans un troisième temps importons l'image PNG dans R et transformons l'objet importé en type *raster*
```{r,message=FALSE,warning=FALSE}
library(png)
myTile <- readPNG("Rochebrune.png", native = FALSE)
mapc <- as.raster(myTile)
```

4. Changement de classe et premiers attributs declasse ggmap
```{r,message=FALSE,warning=FALSE}
class(mapc) <- c("ggmap","raster")
attr(mapc,"source") <- "OSM"
attr(mapc,"maptype") <- "terrain"
attr(mapc,"zoom") <- zoom
```

5. Dernier attribut de la classe ggmap: la bounding box, l'attribut *bb*
   a. programmons une fonction pour calculer la longitude latitude depuis les coordonnées de Mercator
```{r,message=FALSE,warning=FALSE}
lonlat <- function(x,y,zoom) {
    lon <- x/2^zoom*360-180
    lat <- atan(sinh(pi-y/(2^zoom)*2*pi))*180/pi
    return(cbind.data.frame(lon=lon,lat=lat))
    }
```
  b. les 4 bords de la tuiles (en coordonnées de Mercator) sont obtenus en partant du bord *xtile* *ytile* (en bas à gauche) et en ajoutant 1 ou pas
```{r,message=FALSE,warning=FALSE}
intbbx <- 0:1
intbby <- 0:1
ajouts <- expand.grid(xtile+intbbx,ytile+intbby)
```
  c. en utilisant la fonction *lonlat* transformons les 4 bords de Mercator vers lon/lat et calculons la bounding box 
```{r,message=FALSE,warning=FALSE}
library(ggmap)
mabb <- make_bbox(lon,lat,lonlat(ajouts[,1],ajouts[,2],zoom),f=0)
```
  d. ajustons le resultat au bon format: data-frame avec noms adequats dans le bon ordre et le tout devient l'attribut *bb*
```{r,message=FALSE,warning=FALSE}
mabb <- data.frame(matrix(mabb,nrow=1))
names(mabb) <- c("ll.lon","ll.lat","ur.lon","ur.lat")
attr(mapc,"bb") <- mabb[,c("ll.lat","ll.lon","ur.lat","ur.lon")]
```
6. Trace de la tuile qui est maintenant au bon format
```{r,message=FALSE,warning=FALSE}
ggmap(mapc)
```
7. Plusieurs tuiles:
Le départ est identique
```{r,message=FALSE,warning=FALSE}
lon <- 6.615982
lat <- 45.85161
zoom <- 13
xx <- (lon+180)/360 * 2^zoom
yy <- (1- log(tan(lat*pi/180)+1/cos(lat*pi/180)) /pi)*2^(zoom-1) 
xtile <- floor(xx)
ytile <- floor(yy)
```
Le télechargement de plusieurs tuiles autour (2 couronnes d'où le vecteurs de -2 à +2)
```{r,message=FALSE,warning=FALSE}
inttelex <- -2:2
intteley <- -2:2
ajouts <- expand.grid(xtile+inttelex,ytile+intteley)
blocs <- expand.grid(1:5,1:5)
listeUrlStr <- paste("https://b.tile.openstreetmap.org/",zoom,"/",ajouts[,1],"/",ajouts[,2],".png",sep="")
listeDest <- paste(tempfile(),1:nrow(ajouts),sep="")
if (.Platform$OS.type=="windows") {
  for (i in 1:length(listeUrlStr)) {
    download.file(listeUrlStr[i],listeDest[i],method="wininet",mode="wb",quiet=TRUE) 
  }
} else {
download.file(listeUrlStr,listeDest,method = "libcurl",quiet=TRUE)
}
```


L'agencement de ces tuiles (256x256) en une seule matrice *raster*
```{r,message=FALSE,warning=FALSE}
mapf <- matrix(0,256*length(inttelex),256*length(intteley))
for (i in 1:nrow(ajouts)) {
    myTile <- readPNG(listeDest[i], native = FALSE)
    ## raster
    mapc <- as.raster(myTile)
    ## depot dans la matrice
    mapf[((blocs[i,1]-1)*256+1):(blocs[i,1]*256),
    ((blocs[i,2]-1)*256+1):(blocs[i,2]*256)] <- mapc
}
```

Les attributs basiques et la classe *ggmap*
```{r,message=FALSE,warning=FALSE}
class(mapf) <- c("ggmap","raster")
attr(mapf,"source") <- "OSM"
attr(mapf,"maptype") <- "terrain"
attr(mapf,"zoom") <- zoom
```
Le calcul de la bounding box (en réutilisant la fonction *lonlat* du 5.a)
```{r,message=FALSE,warning=FALSE}
inttelex <- -2:3
intteley <- -2:3
ajouts <- expand.grid(xtile+inttelex,ytile+intteley)
library(ggmap)
mabb <- make_bbox(lon,lat,lonlat(ajouts[,1],ajouts[,2],zoom))
mabb <- data.frame(matrix(mabb,nrow=1))
names(mabb) <- c("ll.lon","ll.lat","ur.lon","ur.lat")
## attribut bbox
attr(mapf,"bb") <- mabb[,c("ll.lat","ll.lon","ur.lat","ur.lon")]
```
Le graphique final
```{r,message=FALSE,warning=FALSE}
ggmap(mapf)
```

