---
title: "Data Science, </br>Séance 2 : rappels de R"
author: "Etienne Côme"
date: "21 novembre 2019"
output:
  beamer_presentation:
    toc: false
    incremental: false
  revealjs::revealjs_presentation:
    theme: night
    transition: none
    self_contained: true
    css: slides.css
---

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

## R

<ul>
<li> language de <span class="red"> haut niveau </span> 
<li> support natif des valeur manquantes
<li> programation objet
<li> éco-système vivant : beaucoup de packages 
<li> <span class="red">! plutôt permisif</span> 
<li> <a href="http://cran.r-project.org/doc/contrib/Lam-IntroductionToR_LHL.pdf">http://cran.r-project.org/doc/contrib/Lam-IntroductionToR_LHL.pdf</a>
<li> ...
</ul>

## Les types de base
les vecteurs :
```{r, echo=TRUE}
# vecteur d'entier
a = c(1,5,10)
class(a)
# de chaine de caractère 
b = c("a","g","t","t","c","g","g")
class(b)
```
<ul>
<li>permet de stocker des éléments de même type
<li>opérations de bases c, length, seq, rep, indexation logique
</ul>

## Les types de base
les vecteurs, manipulations de bases :
```{r, echo=TRUE}
length(a)
a[1:2]
i = 1:2;a[i]
i = seq(1,length(b),2);b[i]
i = rep(1,5);b[i]
i = rep(c(1,2),5);b[i]
i = rep(c(1,2),each=3);b[i]
i = (b=="g");b[i]
```



## Les types de base
<h4>les facteurs :</h4>
les vecteurs, manipulations de bases :
```{r, echo=TRUE}
b = c("a","g","t","t","c","g","g")
c = factor(b,levels=c("a","t","g","c"))
levels(c)
unclass(c)
```
<ul>
<li>type particulier de vecteurs pour coder des catégories "les niveaux (levels)"
<li>opérations de bases c, length, levels, unclass
<li><span class="red">! interprétation des chaines de caractères comme des facteurs lors de la création d'une data.frame, cf option stringAsFactor</span>
</ul>



## Les types de base
<h4>Les matrices :</h4>
```{r, echo=TRUE}
# matrice d'entier
a = matrix(c(1,5,10,10),2,2)
# de chaine de caractère 
b = rbind(c("a","g"),c("t","t"),c("c","g"),c("t","g"))
c = cbind(c("a","g"),c("t","t"),c("c","g"),c("t","g"))
```
<ul>
<li>permet de stocker des éléments de même type
<li>opérations de bases dim, rbind, cbind, indexation logique
</ul>

## Les types de base
<h4>Les matrices :</h4>
```{r, echo=TRUE}
dim(b)
t(b)
dim(t(b))
a[1,]
b[,2]
c[c[,1]=="a",]
```
<ul>
<li>permet de stocker des éléments de même type
<li>opérations de bases dim, rbind, cbind, indexation logique
</ul>



## Les types de base
<h4>Les arrays :</h4>

```{r, echo=TRUE}
# tenseur de dimension 3
a = array(runif(50),dim=c(5,5,2))
a[1,,]
a[,5,]
a[,2,1]
```
<ul>
<li>permet de stocker des éléments de même type
<li>opérations de bases dim, indexation logique
</ul>



## Les types de base
<h4>Les listes :</h4>

```{r, echo=TRUE}
l = list(a,b,c)
length(l)
l[[2]]
l = list(a=a,b=b,c=c)
```
<ul>
<li>permet de stocker des éléments de type différents
<li>opérations de bases length
</ul>

## Les types de base
<h4>Les listes :</h4>

```{r, echo=TRUE}
l$c
l[[2]]
```
<ul>
<li>permet de stocker des éléments de type différents
<li>opérations de bases length
</ul>


## Les types de base
<h4>Les data.frame :</h4>
```{r, echo=TRUE,results='hide'}
d = data.frame(v1=rep("a",10),v2=1:10,v3=runif(10))
dim(d)
d$v1
d$v4 = factor(rep(c("a","b"),5),levels=c("a","b"))
d[d$v4=="a",]
d[,"v2"]
d[,c(3,1)]
d[,c("v2","v4")]
names(d)
summary(d)
```
<ul>
<li>permet de stocker des éléments de type différents
<li> = liste de vecteurs només indexable et manipulable comme une matrice
<li>opérations de bases dim, cbind, rbind, names, summary
</ul>

## Les fonctions
```{r, echo=TRUE,results='hide'}
f = function(a,b){
  return(a-b)
}
f(5,6)
f(b=5,a=6)
f = function(a=32,b=12){
  a-b
}
f()
f(5,6)
f(b=5,a=6)
```
<ul>
<li>une variable comme une autre ?
<li>argument nomé et valeur par défaut
<li>pas besoin de return explicite
</ul>


## Les structures de contrôle
```{r, echo=TRUE,results='hide'}
for (i in 1:length(a)){}
while(i > 4){i=i-1}
```
<span class="red">! éviter les boucles for, while préférer les opérations vectorielle</span>

```{r, echo=TRUE}
a=runif(100000)
t=Sys.time()
for (i in 1:length(a)){a[i]=a[i]+5}
t1=Sys.time()-t
t1
```

<span class="green">Version vectorielle</span>
```{r, echo=TRUE}
t=Sys.time()
a=a+5
t2=Sys.time()-t
t2
as.numeric(t1)/as.numeric(t2)
```


## Quelques fonctions vectorielles
somme (sum), somme cumulée (cumsum), différences finies (diff), max, min ...
```{r, echo=TRUE,results='hide'}
a=data.frame(v1=runif(5000),v2=rnorm(5000),v3=rbinom(5000,5,0.2))
# opération algébrique de base
a$v1+a$v2;a$v1*a$v2;a$v1/a$v2

# produit matriciel
t(a$v1)%*%a$v2

# somme et somme cumulé
sum(a$v2);cumsum(a$v1)

# différence
diff(a$v2)
```

## Quelques fonctions vectorielles
somme (sum), somme cumulée (cumsum), différences finies (diff), max, min ...
```{r, echo=TRUE,results='hide'}
# max, min ...
max(a$v3)
which.max(a$v1)
which(a$v1>0.2)

# concatenation de chaine de caractères
paste(a$v1,a$v2);paste0(a$v1,a$v2)

# sommes sur les matrices
b=matrix(runif(100),10,10)
sum(b);rowSums(b);colSums(b)
```

## Apply, lapply, sapply
Appliquer une fonction à chaque élément d'un objet
```{r, echo=TRUE,results='hide'}
a=data.frame(v1=runif(5000),v2=rnorm(5000),v3=rbinom(5000,5,0.2))
# appliquer à chaque lignes
r=apply(a,1,sum)
head(r);class(r);dim(r)

# appliquer à chaque colonnes
r=apply(a,2,function(col){c(max(col),which.max(col))})
r;class(r);dim(r)

# appliquer à tous les éléments d'une liste
b=list(v1=runif(5000),v2=rnorm(5000),v3=rbinom(5000,5,0.2))
r=lapply(b,which.max)
r;class(r)
r=sapply(b,which.max)
r;class(r)
```
<span class="red">à préférer aux boucles...</span>






## Subset : sample, logical indexing
Sélectionner une partie des données
```{r, echo=TRUE}
#logical indexing
a[a$v1>0.98 & a$v3==3,]

#fonction subset
subset(a,v1>0.98 & v3==3)
```

## Binning : cut
Prétraiter les variables pour construires des facteurs // intervalles
```{r, echo=TRUE}
r=cut(a$v2,c(-Inf,-3,-2,2,1,Inf))
class(r);head(r)
```


## Jointure : merge, %in%, match


```{r, echo=TRUE}
a=data.frame(id=1:500,val1=runif(500))
b=data.frame(id=sample(500,500),val2=runif(500))

# jointure par colonne de même nom
c=merge(a,b)

# recherche des indices de correspondances
match(a$id,b$id)[1:10]

# jointure manuelle
d=cbind(a,b$val2[match(a$id,b$id)])
sum(d!=c)
```
## Jointure : merge, %in%, match


```{r, echo=TRUE}
# matching multiples 
b=data.frame(id=sample(500,1000,replace=T),val2=runif(1000))
length(match(a$id,b$id))
length(match(b$id,a$id))
head(a$id %in% b$id)
length(a$id %in% b$id)
c=merge(a,b)
dim(c)
c=merge(a,b,all.x=T)
dim(c)
```

## Aggrégation : tapply, by, aggregate

```{r, echo=TRUE}
a=data.frame(id=1:500,val1=runif(500),val2=factor(rbinom(500,5,0.4)))
aggregate(a$val1,list(a$val2),sum)

```
## Aggrégation : tapply, by, aggregate

```{r, echo=TRUE}
tapply(a$val1,list(a$val2),summary)
```


## Aggrégation : tapply, by, aggregate

```{r, echo=TRUE}
by(a$val1,list(a$val2),summary)
```

## Comptage : table
```{r, echo=TRUE}
table(a$val2)
a$val3=rep(c("a","t","g","c"),500/4)
table(a[,c('val2','val3')])
```



