lab_r.Rmd

---
title: "Intro to R"
subtitle: "Workshop on RNA-Seq"
output:
  bookdown::html_document2:
    highlight: textmate
    toc: true
    toc_float:
      collapsed: true
      smooth_scroll: true
      print: false
    toc_depth: 4
    number_sections: true
    df_print: default
    code_folding: none
    self_contained: false
    keep_md: false
    encoding: 'UTF-8'
    css: "assets/lab.css"
    include:
      after_body: assets/footer-lab.html
---

```{r,child="assets/header-lab.Rmd"}
```

```{r,include=FALSE}
# data handling
library(dplyr)
#library(tidyr)
#library(stringr)

# plotting
library(ggplot2)

library(biomaRt) # annotation
library(DESeq2) # rna-seq
library(edgeR) # rna-seq
```

R is a programming language for statistical computing, and data wrangling. It is open-source, widely used in data science, has a wide range of functions and algorithms for graphing and data analyses.

# Assignment operator

Variables are assigned usually using the `<-` operator. The `=` operator also works in a similar way for most part.

```{r}
x <- 4
x = 4
x
```

# Arithmetic operators

The commonly used arithmetic operators are shown below returning a number.

```{r}
x <- 4
y <- 2

# add
x + y

# subtract
x - y

# multiply
x * y

# divide
x / y

# modulus
x %% y

# power
x ^ y
```

# Logical operators

Logical operators return a logical `TRUE` or `FALSE`.

```{r}
# equal to?
x == y

# not equal to?
x != y

# greater than?
x > y

# less than?
x < y

# greater than or equal to?
x >= y

# less than or equal to?
x <= y
```

# Data types

```{r}
class(1)
class("hello")
class(T)
```

```{r}
x <- c(2,3,4,5,6)
y <- c("a","c","d","e")
z <- factor(c("a","c","d","e"))
class(z)
```

```{r}
x <- matrix(c(2,3,4,5,6,7),nrow=3,ncol=2)
class(x)
str(x)
```

```{r,results="markup"}
dfr <- data.frame(x = 1:3, y = c("a", "b", "c"))
print(dfr)
class(dfr)
str(dfr)
```

# Accessors

Vectors positions can be accessed using `[]`. R follows 1-based indexing.

```{r}
x <- c(2,3,4,5,6)
x
x[2]
```

Dataframe or matrix positions can be accessed using `[]` specifying row and column like `[row,column]`.

```{r}
dfr <- data.frame(x = 1:3, y = c("a", "b", "c"))
dfr
dfr[1,]
dfr[,1]
dfr[2,2]
```


# Functions

```{r}
# generate 10 random numbers between 1 and 200
x <- sample(x=1:200,10)
x

# length
length(x)

# sum
sum(x)

# mean
mean(x)

# median
median(x)

# min
min(x)

# log
log(x)

# exponent
exp(x)

# square-root
sqrt(x)

# round
round(x)

# sort
sort(x)
```

Some useful string functions.

```{r}
a <- "sunny"
b <- "day"

# join
paste(a, b)

# find a pattern
grep("sun", a)

# number of characters
nchar("sunny")

# to uppercase
toupper("sunny")

# to lowercase
tolower("SUNNY")

# replace pattern
sub("sun", "fun", "sunny")

# substring
substr("sunny", start=1, stop=3)
```

Some general functions

```{r}
print("hello")
print("world")
cat("hello")
cat(" world")
cat("\nhello\nworld")
```

# Merging

Two strings can be joined together using `paste()`.

```{r}
a <- "sunny"
b <- "day"

paste(a, b)
paste(a, b, sep="-")
```

The function `c()` is used to concatenate objects.

```{r}
a <- "sunny"
b <- "day"

c(a,b)
```

The function `cbind()` is used to join two dataframes column-wise.

```{r}
dfr1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
dfr2 <- data.frame(p = 4:6, q = c("d", "e", "f"))
dfr1
dfr2

cbind(dfr1,dfr2)
```

Similarily, `rbind()` is used to join two dataframes row-wise.

```{r}
dfr1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
dfr2 <- data.frame(x = 4:6, y = c("d", "e", "f"))
dfr1
dfr2

rbind(dfr1,dfr2)
```

Two dataframes can be merged based on a shared column using the `merge()` function.

```{r}
dfr1 <- data.frame(x = 1:4, p = c("a", "b", "c","d"))
dfr2 <- data.frame(x = 3:6, q = c("l", "m", "n","o"))
dfr1
dfr2

merge(dfr1,dfr2,by="x")
merge(dfr1,dfr2,by="x",all.x=T)
merge(dfr1,dfr2,by="x",all.y=T)
merge(dfr1,dfr2,by="x",all=T)
```


# Packages

R packages extend the functionality of base R. R packages are stored in repositories of which the most commonly used is called [CRAN](https://cran.r-project.org/) (The Comprehensive R Archive Network).

Packages are installed using the function `install.packages()`. Let's install the graphics and plotting package `ggplot2` which will be useful in later sections.

```{r,eval=FALSE}
install.packages("ggplot2",dependencies=TRUE)
```

Packages on BioConductor can be installed as follows:

```{r,eval=FALSE}
source("https://bioconductor.org/biocLite.R")
biocLite("biomaRt")
```

Packages on GitHub can be installed using the function `install_github()` from package `devtools`.

Packages can also be installed from a local zipped file by providing a local path ans setting `type="source"`.

```{r,eval=FALSE}
install.packages("./dir/package.zip",type="source")
```

Inside RStudio, installing packages is much easier. Go to the **Packages** tab and click **Install**. In the window that opens up, you can find your package by typing into the **Packages** field and clicking **Install**. Bioconductor packages can be added to this list by setting it using `setRepositories()`.

# Graphics

## Base

R is an excellent tool for creating graphs and plots. The graphic capabilities and functions provided by the base R installation is called the base R graphics. Numerous packages exist to extend the functionality of base graphics.

We can try out plotting a few of the common plot types. Let's start with a scatterplot. First we create a `data.frame` as this is the most commonly used data object.

```{r}
dfr <- data.frame(a=sample(1:100,10),b=sample(1:100,10))
```

Now we have a dataframe with two continuous variables that can be plotted against each other.

```{r}
plot(dfr$a,dfr$b)
```

This is probably the simplest and most basic plots. We can modify the x and y axis labels.

```{r}
plot(dfr$a,dfr$b,xlab="Variable a",ylab="Variable b")
```

We can change the point to a line.

```{r}
plot(dfr$a,dfr$b,xlab="Variable a",ylab="Variable b",type="b")
```

Let's add a categorical column to our dataframe.

```{r}
dfr$cat <- rep(c("C1","C2"),each=5)
```

And then colour the points by category.

```{r}
# subset data
dfr_c1 <- subset(dfr,dfr$cat == "C1")
dfr_c2 <- subset(dfr,dfr$cat == "C2")

plot(dfr_c1$a,dfr_c1$b,xlab="Variable a",ylab="Variable b",col="red",pch=1)
points(dfr_c2$a,dfr_c2$b,col="blue",pch=2)

legend(x="topright",legend=c("C1","C2"),
       col=c("red","blue"),pch=c(1,2))
```

Let's create a barplot.

```{r}
ldr <- data.frame(a=letters[1:10],b=sample(1:50,10))
barplot(ldr$b,names.arg=ldr$a)
```

## Grid

Grid graphics have a completely different underlying framework compared to base graphics. Generally, base graphics and grid graphics cannot be plotted together. The most popular grid-graphics based plotting library is **ggplot2**.

Let's create the same plot are before using **ggplot2**. Make sure you have the package installed.

```{r}
library(ggplot2)

ggplot(dfr,aes(x=a,y=b,colour=cat))+
  geom_point()+
  labs(x="Variable a",y="Variable b")
```

It is generally easier and more consistent to create plots using the ggplot2 package compared to the base graphics.

Let's create a barplot as well.

```{r}
ggplot(ldr,aes(x=a,y=b))+
  geom_bar(stat="identity")
```

# Input/Output

Input and output of data and images is an important aspect with data analysis.

## Text

Data can come in a variety of formats which needs to be read into R and converted to an R data type.

Text files are the most commonly used input. Text files can be read in using the function `read.table`. We have a sample file to use: **iris.txt**.

```{r,eval=FALSE}
dfr <- read.table("iris.txt",header=TRUE,stringsAsFactors=F)
```

This reads in a tab-delimited text file with a header. The argument `sep='\t'` is set by default to specify that the delimiter is a tab. `stringsAsFactors=F` setting ensures that character columns are not automatically converted to factors.

It's always a good idea to check the data after import.

```{r,eval=FALSE}
head(dfr)
```

```{r,eval=FALSE}
str(dfr)
```

Check `?read.table` for other wrapper functions to read in text files.

Let's filter this data.frame and create a new dataset.

```{r,eval=FALSE}
dfr1 <- dfr[dfr$Species == "setosa",]
```

And we can write this as a text file.

```{r,eval=FALSE}
write.table(dfr1,"iris-setosa.txt",sep="\t",row.names=F,quote=F)
```

`sep="\t"` sets the delimiter to tab. `row.names=F` denotes that rownames should not be written. `quote=F` specifies that doubles must not be placed around strings.

## Images

Let's take a look at saving plots.

## Base graphics

The general idea for saving plots is open a graphics device, create the plot and then close the device. We will use **png** here. Check out `?png` for the arguments and other devices.

```{r,eval=FALSE}
dfr <- data.frame(a=sample(1:100,10),b=sample(1:100,10))

png(filename="plot-base.png")
plot(dfr$a,dfr$b)
dev.off()
```

## ggplot2

The same idea can be applied to ggplot2, but in a slightly different way. First save the file to a variable, and then export the plot.

```{r,eval=FALSE}
p <- ggplot(dfr,aes(a,b)) + geom_point()

png(filename="plot-ggplot-1.png")
print(p)
dev.off()
```

**ggplot2** also has another easier helper function to export images.

```{r,eval=FALSE}
ggsave(filename="plot-ggplot-2.png",plot=p)
```

# Getting help

- Use `?function` to get function documentation
- Use `??bla` to search for a function
- Use `args(function)` to get the arguments to a function
- Go to the package CRAN page/webpage for vignettes
- [R Cookbook](http://www.cookbook-r.com/): General purpose reference.
- [Quick R](https://www.statmethods.net/): General purpose reference.
- [Stackoverflow](https://stackoverflow.com/): Online community to find solutions to your problems.

# Session info

```{r,echo=FALSE}
sessionInfo()
```

***