---
title: "Introduktion til R"
author: "The ASTA team"
# output: html_document
output:
  learnr::tutorial:
    progressive: true
    allow_skip: true
runtime: shiny_prerendered
description: "This tutorial introduces some of the most basic R syntax, and it scratches the surface of the mosaic package. The intention of the tutorial merely is to give students (who might never have touched programming before) a chance to see some R, such that it doesn't feel to intimidating at course start where they also have a lot of other new things to learn. The tutorial assumes that the actual course is also going to introduce R."
---

```{r setup, include=FALSE}
## BEWARE: Package `gradethis` is silently assumed below. It must be installed from GitHub.
knitr::opts_chunk$set(echo = TRUE)
inst_pkg <- installed.packages()[,"Package"]
if(!("mosaic" %in% inst_pkg)){
  install.packages("mosaic", repos = "https://cloud.r-project.org")
}
if(!("palmerpenguins" %in% inst_pkg)){
  install.packages("palmerpenguins", repos = "https://cloud.r-project.org")
}
library(mosaic)
library(palmerpenguins)
library(learnr)
tutorial_options(exercise.timelimit = 5)
if(require(gradethis)){
  gradethis::gradethis_setup()
}
```


## Vejledningens formål

I denne vejledning vil vi gennemgå noget af den mest basale syntaks i programmeringssproget R, og vi vil skrabe i overfladen på pakken `mosaic`, som vi kommer til at benytte en del igennem kurset.

Vejledningen er lavet, da tidligere studerende har efterspurgt en kort introduktion til R, før selve kurset går i gang. 
Men da det ikke er en forudsætning for kurset, at man har arbejdet med R eller andre programmeringssprog tidligere, så vil vi stadig gøre vores bedste for at introducere det nødvendige R i løbet af kurset.
Intentionen med vejledningen er derfor **ikke** at give en dybdegående introduktion, men blot at lade den studerende bruge R i nogle forskellige sammenhænge, så det ikke virker som en fuldstændigt ukendt verden, når kurset begynder.


## Programmeringssproget R

R er et programmeringssprog og en software, der er specialiseret til brug indenfor statistik og dataanalyse. 
Man kan se det som en ekstra avanceret lommeregner, der gennem et tilpasset sprog kan instrueres i at udføre specialiserede beregninger.
Vi siger tit, at vi skriver R-kode, når vi skriver en række instrukser i sproget R.

RStudio er et såkaldt *Interactive Development Environment* (IDE), hvori vi nemt kan arbejde med R og køre vores R-kode.

### R pakker
R-softwaren kommer med nogle basale indbyggede funktioner, men man har mulighed for at hente udvidelser gennem såkaldte *pakker* (og man kan evt. selv lave nye pakker).

For at benytte en pakkes funktionalitet må vi først installere den, hvilket enten kan gøres med peg-og-klik i en menu i RStudio eller med en kommando på formen `install.packages('pakkenavn')`. 
Installation af pakken skal kun gøres een gang på en given computer.

Når pakken er installeret, kan man tilgå dens indhold. 
Ønsker man f.eks. at tilgå en funktion eller et datasæt fra pakken, kan man skrive `pakkenavn::funktionsnavn` eller `pakkenavn::datanavn`.
Hvis man skal bruge en pakkes indhold mange gange, så er det dog ret omstændigt hele tiden at skrive `pakkenavn::`, og så kan man i stedet frigive hele pakkens indhold for vores R-session med en kommando på formen `library(pakkenavn)` eller `library("pakkenavn")`, hvor den første version uden anførselstegn er mest gængs. 
Herefter vil vi kunne tilgå pakkens funktioner m.m. ved blot ved skrive funktionsnavnet.
Hvis vi starter en ny R session (lukker ned og starter igen osv) så skal man igen bruge `library`-kommandoen for at frigive pakkens indhold.

### Installation af pakker
```{r pakkeinstallation, echo=FALSE}
question("Vi vil som nævnt komme til at bruge `mosaic`-pakken en hel del i løbet af kurset, men hvordan kan man installere den?",
  answer("Man kan skrive `install.package(mosaic)` i konsollen.", message = "Det ligner, men syntaksen er lidt anderledes."),
  answer("Man kan skrive `install.packages(mosaic)` i konsollen.", message = "Det ligner, men syntaksen er lidt anderledes."),
  answer("Man kan skrive `install.packages('mosaic')` i konsollen.", correct = TRUE, message = "Korrekt! Husk at der skal apostrof eller anførselstegn omkring pakkenavnet, når man vil installere en pakke."),
  answer("Man kan skrive `install(mosaic)` i konsollen.", message = "Man skal bruge funktionen `install.packages`."), allow_retry = TRUE
)
```

### Pakker til brug i session

```{r pakkeindlaesning, echo=FALSE}
question("Og hvad skal du indtaste i din konsol, for at frigive alle pakkens funktioner til din R-session?",
  answer("Man kan skrive `load(mosaic)` i konsollen.", message = "Du skal bruge funktionen `library`."),
  answer("Man kan skrive `library(mosaic)` i konsollen.", correct = TRUE, message = "Korrekt! Det er også tilladt med apostrof/anførselstegn omkring pakkenavnet, men det undlades sædvanligvis."),
  answer("Man kan skrive `install(mosaic)` i konsollen.", message = "Man skal bruge funktionen `library`."), allow_retry = TRUE
)
```

### Pingvindata
Vi vil senere bruge et datasæt, der ligger i pakken `palmerpenguins`, men da det er det eneste, vi vil bruge fra den pakke, så vil vi undlade at bruge `library`-funktionen. Hvordan kan vi tilgå datasættet `penguins` fra pakken `palmerpenguins`?
```{r dataindlaesning, exercise=TRUE, eval=FALSE}
# Indtast den nødvendige kode for at hente datasættet penguins fra pakken palmerpenguins:
```
<div id="dataindlaesning-hint">
**Tip:** Hvis blot vi har installeret en pakke, så kan vi tilgå dens indhold med syntaksen `pakkenavn::datanavn`.
</div>
```{r dataindlaesning-solution}
palmerpenguins::penguins
```
```{r dataindlaesning-code-check}
grade_this_code()
```

### Gem pingvindata
Med koden `palmerpenguins::penguins` tilgår vi kun datasættet `penguins`, men vi vil ofte gerne gemme vores data i et objekt (en såkaldt `dataframe`), så vi nemmere kan arbejde mere direkte med det (hvis vi f.eks. vil tilføje flere kolonner til datasættet eller udtage en delmængde af det). 
Vi kan gøre dette med en kodelinje på formen: `pingviner <- palmerpenguins::penguins`. 
Det er altid en god idé at tjekke, om man har fået sit data indlæst korrekt. 
Et hurtigt tjek kan være at bruge funktionen `head()` på sin `dataframe`. 
Denne funktion vil vise de første linjer af datasættet, hvormed man visuelt kan inspicere, om alt ser ud som forventet (og man kan danne sig et fint overblik over, hvilke typer af målinger data indeholder).

Gem nu det tidligere tilgåede datasæt med navnet `pingviner` og tjek, om alt ser korrekt ud vha. funktionen `head()`.
```{r gemme_data, exercise=TRUE, eval=FALSE}
# Indtast de nødvendige to linjers kode for at gemme datasættet penguins i et objekt og se starten af datasættet:
```
<div id="gemme_data-hint">
**Tip:** Vi kan gemme datasættet ved at tildele det til et objekt ved hjælp af operatoren `<-`.
</div>
```{r gemme_data-solution}
pingviner <- palmerpenguins::penguins
head(pingviner)
```
```{r gemme_data-check}
grade_result(
  pass_if(~identical(.result, head(pingviner)))
)
```

```{r definer_pingviner, echo=FALSE}
pingviner <- palmerpenguins::penguins
```

## Plots

Når vi har indlæst data korrekt er det altid godt at lave noget grafik for at få en forståelse af data. 
De grafik-kommandoer vi bruger i kurset stammer fra pakken `ggformula` som automatisk indlæses når hovedpakken `mosaic` indlæses, hvilket vi altid skal huske at gøre (ligesom vi sikrer os at data er gemt med det navn vi bruger resten af tiden):
```{r}
library(mosaic)
pingviner <- palmerpenguins::penguins
```

Her er et eksempel på en grafik-kommando (de starter alle med `gf_`)
```{r length_mass_points}
gf_point(bill_length_mm ~ body_mass_g, data = pingviner)
```

Dette viser en generel skabelon `goal(y ~ x, data = DATA, ...)` vi kommer til at bruge rigtig meget:

1. Først fortæller vi R vores "goal" altså hvad vil vi opnå: I dette tilfælde `gf_point` som giver et punkt-plot.
2. Den næste del er en såkaldet "formel" i R, `y ~ x`, og kan læses som: "y forklaret af x", "y modelleret af x", "y vs. x", etc: Her betyder `bill_length_mm ~ body_mass_g` hvordan næblængden i millimeter afhænger af vægten i gram.
3. Dernæst fortæller vi R hvilket datasæt, der indeholder de variable vi henviser til: `data = pingviner`.
4. Endelig kan man angive flere ting (her markeret med `...`) såsom grupper, farver osv. hvilket vi lærer senere.

Vi kan tilføje et yderligere element til formlen ved at bruge ` | `, hvilket læses som "for hver", så hvis vi vil se sammenhængen mellem næblængde og vægt for hver ø der er indsamlet data fra:
```{r}
gf_point(bill_length_mm ~ body_mass_g | island, data = pingviner)
```

Endelig kan man tilføje farver (bemærk igen symbolet `~` som indikerer at der skal farves ud fra værdien af en variabel i datasættet):
```{r}
gf_point(bill_length_mm ~ body_mass_g | island, data = pingviner, color = ~species)
```

Vi kan naturligvis kun undersøge sammenhængen mellem variable hvis vi ved hvad de hedder. 
Vi kan finde alle variabelnavne i datasætte med kommandoen `names()`:
```{r}
names(pingviner)
```

Prøv selv at plotte sammenhængen mellem to variable fra datasættet (du må også gerne splitte op i flere plots og farver):
```{r plot_two_var, exercise=TRUE, exercise.setup="definer_pingviner"}
# Modificer koden herunder for at plotte en anden sammenhæng efter eget valg
gf_point(bill_length_mm ~ body_mass_g, data = pingviner)
```
<div id="plot_two_var-hint">
**Tip:** Du skal blot udskifte variablene `bill_length_mm` og `body_mass_g` med to andre. F.eks. `flipper_length_mm` og `bill_depth_mm`.
</div>

## Numerisk opsummering af data

I dette plot ser vi på sammenhæng mellem næblængde og ø:
```{r}
gf_point(bill_length_mm ~ island, data = pingviner)
```

Bemærk at `island` er en tekst-variabel, så i første omgang giver et punkt-plot ikke mening, men R har så bare valgt at placere dem ved værdierne 1, 2 og 3 på 1.-aksen, men med tallene på aksen erstattet af teksten. 
Når man ser plottet kunne man meget naturligt spørge sig selv, hvad gennemsnitslængden i grunden er for hver ø?

Den udregner vi efter samme princip som før `goal(y ~ x, data = DATA, ...)`:
```{r}
mean(bill_length_mm ~ island, data = pingviner)
```
Bemærk at to gennemsnit er `NA` hvilket betyder "Not available", dvs. de mangler.
Dette sker fordi der er nogle pingviner som vi ikke har registreret næblængden af (f.eks. pingvin nummer 4):
```{r}
head(pingviner)
```
Vi kan fortælle R, at de manglende observationer bare skal slettes fra data når vi udregner gennemsnittet:
```{r}
mean(bill_length_mm ~ island, data = pingviner, na.rm = TRUE)
```

Der findes mange andre numeriske opsummeringer af data end gennemsnittet, hvor kommandoerne har oplagte navne som `min()` for minimum osv. 
Prøv selv at finde den maksimale næblængde for hver pingvin-art:
```{r max_groups, exercise=TRUE, exercise.setup="definer_pingviner"}
## Kopier kommandoen ovenfor og modificer den på passende vis.
```
<div id="max_groups-hint">
**Tip:** Du skal bruge kommandoen `max` med variablene `bill_length_mm` og `species`. Husk `na.rm = TRUE`.
</div>
```{r max_groups-solution}
max(bill_length_mm ~ species, data = pingviner, na.rm = TRUE)
```
```{r max_groups-code-check}
grade_this_code()
```


## Grafik for enkelte variable

Hvis der kun er en enkelt variabel, der skal indgå i hovedplottet, kan vi ikke bruge syntaksen `goal(y ~ x, data = DATA, ...)`, men må udelade `y`.
Så kan vi oftest tænke på det, som om selve kommandoen fortæller, hvad der er på 2.-aksen i stedet for variablen `y`.
F.eks. et søjle-diagram med antal pingviner af hver art:
```{r}
gf_counts(~ species, data = pingviner)
```

Denne type plots kan også arbejdes videre på med opsplitning, farver osv.
Lad os f.eks. se på, om de forskellige pingvinarter fordeler sig forskelligt på de tre øer, hvor data er indsamlet:
```{r island_hist}
gf_percents(~ species | island, data = pingviner, fill = ~species, color = "black")
```

Prøv at kopiere ovenstående kode for at ændre den, så du kan besvare, om hver art udgør den sammen procentdel hvert af årene, som dataindsamlingen har løbet over:
```{r year_hist, exercise=TRUE, exercise.setup="definer_pingviner"}
# Er der samme procentvise fordeling mellem arterne i årene 2007, 2008, 2009?
```
<div id="year_hist-hint">
**Tip:** Du skal blot udskifte variablen `island` med `year`.
</div>