# Introductie tot R, RStudio en R Markdown

Met R MarkDown kan je gemakkelijk webpagina's, documenten en slides maken die tekst, R chunks, plots en Latex vergelijkingen bevatten. Tijdens de tutorialsessies zullen we altijd R Markdown gebruiken. R Markdown vervangt scripts en is erg handig omdat je extra opmerkingen kunt toevoegen aan de hoorcolleges en tutorials.

## Header
De markdown notebook start met een header.
Het bevat ondermeer de titel, de namen van de auteurs en het type RMarkdown file. 
We werken typisch met interactieve html_notebooks tijdens de ontwikkeling van onze code.

``` yaml
---
title: "Introductie tot R Markdown notebooks"
author: "Namen Auteurs"
output:
  html_notebook: default
---
```

Deze header wordt vaak standaard verwijderd als je markdown files download van het web. 
Kopieer de header, startende met de drie mintekens tot en met de drie onderste mintekens.

Plak de header bovenaan je document en sla het document op. 
Het document is nu gedefineerd als een interactieve html_notebook.

## Resultaat bekijken
Door gebruik te maken van notebooks, kan je de wijzigingen die je maakt onmiddellijk opvolgen op een interactieve manier. 
Klik op Preview bovenaan in je RStudio venster om de html versie van de notebook te zien. 

Je zal zien dat de R-code nog niet is uitgevoerd. Hier komen we verder op terug.
Op Windows is het soms zo dat de preview functie pas werkt nadat er een wijziging werd uitgevoerd aan de file en deze werd opgeslagen. 
Je kan bijvoorbeeld een spatie toevoegen en de file opslaan ...
Daarna zou de preview functie een resultaat moeten weergeven.

## Opmaak

Als je iets in vet of cursief wilt benadrukken, gebruik je dubbele sterretjes voor **vet** en enkele sterretjes voor *cursief*. Als je een niet-genummerde lijst wilt toevoegen, gebruik dan een streepje:

- Element 1
- Element 2
- Element 3

Je kunt titels toevoegen met behulp van het hekje \#

# Hoofdtitel met een enkel \#

## ondertitel 1 met twee \#\#

### subsubtitle met drie \#\#\#

#### enz.

# Integreer tekst en R-code

## Eenvoudige berekeningen

Je kunt stukjes R-code integreren in je RMarkdown-bestand. Dit doe je door een omgeving te maken die begint met \`\`\`{r} en eindigt met \`\`\`. 

Hieronder zullen we R-code demonstreren aan de hand van verschillende voorbeelden, zodat je vertrouwd kan geraken met de syntax.

Je kunt RStudio bijvoorbeeld gebruiken als een rekenmachine. Code uitvoeren kan je op verschillende manieren
 - door in een stukje code met je muis te klikken en dan via de "Run"-knop bovenaan in de console op "Run current chunck" te klikken.
 - Door op het groene pijltje te klikken rechts van de chunk. 
 - Door je cursor in/naast de regel te zetten en de toetsencombinatie Ctrl+Enter (Mac: Cmd+Enter) uit te voeren.

Telkens je het document opslaat wordt dan de webpagina (html-file) geupdatet.

Laat de onderstaande code lopen. Sla op en bekijk het resultaat in je html file.

```{r}
1+1
(5-3)+7*10/2
```

- Je kan ook alle chunks laten lopen boven of onder de positie waarop je je bevindt via de "Run"-knop bovenaan in de console en dan "Run all Chunks below" of "Run all Chunks above" te selecteren, respectievelijk. Dat is bijvoorbeeld handig als je iets in de analyse hebt veranderd die een effect heeft op de onderstaande berekeningen.

- Je kan ook de R sessie opnieuw starten en alle chunks volledig opnieuw laten lopen. 

- Het voordeel van een notebook is dat je bij kleine wijzigingen niet de volledige notebook opnieuw moet laten lopen, wanneer het volstaat om enkel de chunks te laten lopen die je hebt aangepast. Daarnaast is het hierdoor erg interactief. Telkens je opslaat zie je onmiddellijk de aanpassingen in de html file.

### Commentaar in R-code 

Je kunt ook binnen je stukjes R-code commentaar schrijven. Commentaar laat je voorafgaan door een \#.

```{r}
# Dit is commentaar.
# Code in commentaar wordt niet uitgevoerd.
# 1+1
```

## Gebruik objecten om resultaten, berekeningen, enz. op te slaan.

Je kunt resultaten van functies of berekeningen opslaan in objecten die je kan bijhouden voor toekomstig gebruik. Dit doe je door middel van `<-` of `=`. 

```{r}
x = 2
x
x <- 3
x
```

De aanbevolen manier in R is om gebruik te maken van `<-`, aangezien `=` ook gebruikt wordt binnen functies. Dit zullen wij vanaf nu dan ook altijd doen.

**TIP:** Een snelle manier om `<-` te bekomen is de toetscombinatie "ALT" + "-".

Je kan met deze variabelen ook berekeningen doen.

```{r}
beta0 <- 1
beta1 <- 2
beta0 + beta1

x <- 4
y <- beta0 + beta1*x
y
```

## Functies

Functies worden opgeroepen met hun functienaam onmiddellijk gevolgd door ronde haakjes (), waarin de verschillende argumenten gespecifieerd kunnen worden.
In dit voorbeeld simuleren we 101 trekkingen uit een normale verdeling aan de hand van de functie `rnorm`

```{r}
# Simuleer 101 trekkingen uit een normale verdeling met gemiddelde 0 en standaarddeviatie 1 en steek ze in object "e1".
e1 <- rnorm(101)
```

## Eerste hulp bij RStudio: "?".

We willen 101 trekkingen uit een normale verdeling met gemiddelde 5 en standaarddeviatie 2 trekken. Hoe wijzigen we het gemiddelde en de standaarddeviatie in de `rnorm`-functie?
Hiervoor bestaat het handige hulpmiddel "?".

```{r}
?rnorm
```

Dit commando opende het helpvenster voor de `rnorm`-functie. We zien dat we voor het gemiddelde het argument `mean` en voor de standaarddeviatie het argument `sd` moeten aanpassen. Onze 101 trekkingen uit een normale verdeling met gemiddelde 5 en standaarddeviatie 2 berekenen we dus als volgt:

```{r}
# Simuleer 101 trekkingen uit een normale verdeling met gemiddelde 5 en standaarddeviatie 2 en steek ze in object "e2".
e2 <- rnorm(101, mean = 5, sd = 2)
```

We willen nu graag een histogram maken van `e1` en `e2`. **Hoe vinden we de correcte functie? Het internet is onze bondgenoot.** We googelen "histogram R function". Hiermee vinden we snel dat `hist` de functie is de we zoeken. We maken de histogrammen.

```{r}
hist(e1)
hist(e2)
```

## Vectoren

R kan ook werken met vectoren. Die worden aangemaakt met de functie `c`.

```{r}
x <- c(1,2,3)
y <- c(3,2,1)
x

# Berekeningen gebeuren voor elk element van de vector.
2*x
x+y
```

Vectoren kunnen slechts elementen bevatten van ????n enkele klasse.

```{r}
# Een voorbeeld van de character-klasse.
x <- c("Biologie", "Biochemie", "Chemie", "Biomedische")
x
class(x)
```

```{r}
# Een voorbeeld van de numerieke klasse.
x <- c(1,2,3)
x
class(x)
```

```{r}
x <- c(1,2,3,"Biologie")
class(x) # Alles werd omgezet naar de character-klasse.
```

Als je het volgende uitvoert, krijg je een error, want een wiskundige operatie met een vector van het klasse character kan niet (dit is, Biologie+1 houdt geen steek).

```{r eval = FALSE}
x + 2 # Al Wiskundige opratie met string kan niet.
```

## Subsets van vectoren

Je kan elementen van objecten selecteren met behulp van vierkante haakjes.

```{r}
x[1] # Selecteer element 1
x[2] # Selecteer element 2
x[c(1,2)] # Selecteer element 1 en 2
x[1:2] # Selecteer element 1 en 2
x[-1] # verwijder het eerste element
```

## Matrices

```{r}
# Merk op bij onderstaande code dat je een commando over meerdere lijnen kan splitsen.
xMat <- matrix(c(5, 6,
                4, 3), byrow=TRUE, nrow=2, ncol=2)
xMat
```

# Je kan de matrix overzichtelijker maken door rij- en kolomnamen toe te voegen

```{r}
rownames(xMat) <- c("rij1", "rij2")
colnames(xMat) <- c("kol1", "kol2")
xMat
```

# Je kan ook met matrices wiskundige berekeningen doen.

```{r}
xMat*2
xMat - 2
yMat <- matrix(c(1, 7,
                2, 3), byrow = TRUE, nrow = 2, ncol = 2)

xMat - yMat # Merk op dat rij- en kolomnamen behouden blijven.
```

Matrices kun je ook subsetten. Dit kan op verschillende manieren.

```{r}
# Subsetten op index
xMat[1, ] # Volledige rij 1!
xMat[ ,1] # Volledige kolom 1!
xMat[2,2] # Element in 2de rij, 2de kolom

# Subsetten op rij- en kolomnaam
xMat["rij1", ] # Volledige rij 1!
xMat[ ,"kol1"] # Volledige kolom 1!
xMat["rij2","kol2"] # Element in 2de rij, 2de kolom
```

## Data frames

Data frames zijn net als matrices tweedimensionale structuren, maar ze kunnen verschillende datatypes samen bevatten. Ze zijn dus ideaal om datasets in op te slaan.

```{r}
# Maak een simpel data frame
# Ons voorbeeld is een data frame met het aantal bedreigde species per taxon in de VS in 2002.
EndangeredSpecies <- data.frame(
  taxon = c("Mammals", "Birds", "Reptiles", "Amphibians", "Fish", "Crustaceans", "Snails", "Insects", "Arachnids", "Clams", "Plants"),
  num.species = c(74, 92, 36, 22, 115, 21, 32, 44, 12, 70, 745)
)
EndangeredSpecies
```

Data frames kun je ook subsetten. Dit kan opnieuw op verschillende manieren.

```{r}
# Subsetten op index
EndangeredSpecies[3,] # Rij 3
EndangeredSpecies[,2] # Kolom 2

# Subsetten op naam
EndangeredSpecies[, "taxon"]

# Bij data frames kan je ook gebruik maken van de "$"-operator om een kolom te selecteren
EndangeredSpecies$taxon
```

## Data importeren

Data importeren in R kan via de functie `read.table`. Hierbij moet je het pad naar je bestand defini??ren en een separator opgeven (bv. "\\t" als het een tab-delimited file is, "," als het een komma is, etc.). Wij zullen er altijd voor zorgen dat je een werkend bestand kunt importeren. Als je ook offline wil kunnen werken, kan je altijd het bestand downloaden en (in plaats van de hyperlink) verwijzen naar de bestandslocatie op je computer.

```{r}
path <- "https://raw.githubusercontent.com/statOmics/statistiekBasisCursus/gh-pages/practica/practicum1/data/lovett.dat"

lovett <- read.table(path, header = TRUE, sep = "\t", dec = ",")
lovett
```

## Doel van de practica en de projecten

**Belangrijk: De bedoeling van de practica en de projecten die jullie zullen maken is om jullie te leren correcte statistische analyses uit te voeren en deze ook correct te rapporteren. Hierbij zullen jullie gebruik maken van RMarkdown in RStudio, wat later ook nog van pas kan komen, bv. bij het maken van jullie thesis. Het is echter NIET de bedoeling om uren te zoeken op wat er misloopt als je iets in R probeert te implementeren. Dus: als je problemen ondervindt om iets te implementeren in R, aarzel niet om ons persoonlijk of via e-mail te contacteren!**

## Integreer R-resultaten inline in de tekst.

We voegen het gemiddelde van 100 gesimuleerde datapunten inline toe en we zullen het afronden op twee cijfers. Hiervoor maken we gebruik van de omgeving die begint met "\`r" en eindigt met "\`". Het gemiddelde van een willekeurige steekproef met 100 observaties getroken uit een standaard normaal verdeling is gelijk aan `r round(mean(rnorm(100)), 2)`.

## Toevoegen van formules door latexvergelijkingen te gebruiken

Je kunt ook vergelijkingen toevoegen met behulp van dubbele \$\$ - tekens, bijvoorbeeld:
$$y_i = \beta_0 + \beta_1 x_i + \epsilon_i$$
Je kunt ook inline-latexcode toevoegen met behulp van enkele \$ - tekens. Bijvoorbeeld het steekproefgemiddelde van y:
$\bar{y}=\sum\limits_{i=1}^{n}\frac{y_i}{n}$
