slide_r_elements_4.Rmd

---
title: "Replication, Control Structures & Functions"
subtitle: "Elements of the R language"
author: "Marcin Kierczak, Nima Rafati, Miguel Redondo"
keywords: bioinformatics, course, scilifelab, nbis, R
output:
  xaringan::moon_reader:
    encoding: 'UTF-8'
    self_contained: false
    chakra: 'assets/remark-latest.min.js'
    css: 'assets/slide.css'
    lib_dir: libs
    include: NULL
    nature:
      ratio: '4:3'
      highlightLanguage: r
      highlightStyle: github
      highlightLines: true
      countIncrementalSlides: false
      slideNumberFormat: "%current%/%total%"
---

exclude: true
count: false

```{r,echo=FALSE,child="assets/header-slide.Rmd"}
```

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

---
name: contents

# Contents of the lecture

- variables and their types
- operators
- vectors
- numbers as vectors
- strings as vectors
- matrices
- lists
- data frames
- objects
- **repeating actions: iteration and recursion**
- **decision taking: control structures**
- **functions in general**
- **variable scope**
- **base functions**

---
name: repeating_actions_1

# Repeating actions

Sometimes you want to repeat certain action several times.  

There are few alternatives in R, for example:  
- `for` loop 
- `while` loop   

---
name: for_loop_0

# Repeating actions — for loop

One way to repeat an action is to use the **for-loop**. 

This is the general syntax:

```{r for.loop.general, eval=FALSE, echo=TRUE}
for (var in seq) {
  expr
}
```
Where:
- var = variable that will take values from the sequence
- seq= sequence of values
- expr = expression to be executed

---
name: for_loop_1
# Repeating actions — for loop

Example. 

```{r for.loop, echo=T}
for (i in 1:5) {
  cat(paste('Performing operation on no.', i), '\n')
}
```

--

A slight modification of the above example.

```{r for.loop2, echo=T}
for (i in c(2,4,6,8,10)) {
  cat(paste('Performing operation on no.', i), '\n')
}
```

---
name: for_loop_counter

# Repeating actions — for loop with a counter

Sometimes, we also want an external counter:

```{r for.loop.cnt, echo=T}
cnt <- 1
for (i in c(2,4,6,8,10)) {
  cat(paste('Iteration', cnt,
            'Performing operation on no.', i), '\n')
  cnt <- cnt + 1
  
}
```

---
name: for_loop_example

# Repeating actions &mdash; for loop, an example

Say, we want to add 1 to every element of a vector:

```{r for.loop.ex1, echo=T}
vec <- c(1:5)
vec

```

```{r for.loop.ex2, echo=T}

for (i in vec) {
  vec[i] <- vec[i] + 1
}
vec
```

--

The above can be achieved in R by means of **vectorization**.  
**Vectorization** is an element-wise operation where you perform task/operation on entire vectors/matrix/data.frames.

```{r for.loop.avoid, echo=T}
vec <- c(1:5)
vec + 1  
```

---
name: vectorization_benchmark

# Repeating actions &mdash; vectorization

Let us compare the time of execution of the vectorized version (vector with 10,000 elements):

```{r for.loop.avoid.timing, echo=T}
vec <- c(1:1e6)
ptm <- proc.time()
vec <- vec + 1
proc.time() - ptm # vectorized
```

--

to the loop version:

```{r for.loop.avoid.timing2, echo=T}
vec <- c(1:1e6)
ptm <- proc.time()
for (i in vec) {
  vec[i] <- vec[i] + 1
}
proc.time() - ptm # for-loop
```


---
name: loops_avoid_growing

# Loops &mdash; avoid growing data

Avoid changing dimensions of an object inside the loop:

```{r avoid.growing, echo=T}
v <- c() # Initialize
for (i in 1:100) {
  v <- c(v, i)
}
```

--

It is much better to do it like this:

```{r avoid.growing2, echo=T}
v <- rep(NA, 100) # Initialize with length
for (i in 1:100) {
  v[i] <- i
}
```

--

Always try to know the size of the object you are going to create!


---
name: while_loop

# Repeating actions &mdash; the while loop

There is also another type of loop in R, the **while loop** which is executed as long as some condition is true.
```{r loop.while, echo=T}
x <- 1
while (x < 5) {
  cat("x equals",x, "\n")
  x <- x + 1
}
```

---
name: recursion
exclude: true
# Any questions so far?
<!-- # Recursion

When we explicitely repeat an action using a loop, we talk about **iteration**. We can also repeat actions by means of **recursion**, i.e. when a function calls itself. Let us implement a factorial $!$:

```{r rec.fact, echo=F}
factorial.rec <- function(x) {
  if (x == 0 || x == 1)
    return(1)
  else
    return(x * factorial.rec(x - 1)) # Recursive call!
}
factorial.rec(5)
```


# Recursion = iteration?
Yes, every iteration can be converted to recursion (Church-Turing conjecture) and vice-versa. It is not always obvious, but theoretically it is doable. Let's see how to implement *factorial* in iterative manner:
```{r rec.fact.iter, echo=T}
factorial.iter <- function(x) {
  if (x == 0 || x == 1)
    return(1)
  else {
    tmp <- 1
    for (i in 2:x) {
      tmp <- tmp * i
    }
    return(tmp)  
  }
}
factorial.iter(5)
```

# Recursion == iteration, really?
More writing for the iterative version, right? What about the time efficiency?  
The recursive version:
```{r rec.fact.timing, echo=F}
ptm <- proc.time()
factorial.rec(20)
proc.time() - ptm
```
And the iterative one:
```{r iter.fact.timing, echo=F}
ptm <- proc.time()
factorial.iter(20)
proc.time() - ptm
```
-->

---

name: if_clause

# Decisions, an if-clause

Often, one has to take a different course of action depending on a flow of the algorithm. Let's print only odd numbers $[1, 10]$:

```{r if, echo=T}
v <- 1:10
for (i in v) {
  if (i %% 2 != 0) { # if clause
    cat(i, ' ')
  }
}
```

---
name:if_else

# Decisions &mdash; if-else

If we want to print 'o' for an odd number and 'e' for an even, we could write either of:

.pull-left-50[
```{r ifelse1, echo=T}
v <- 1:10
for (i in v) {
  if (i %% 2 != 0) { # if clause
    cat('o ')
  }
  if (i %% 2 == 0) { # another if-clause
    cat('e ')
  }
}
```
]

--

.pull-right-50[
```{r ifelse2, echo=T}
v <- 1:10
for (i in v) {
  if (i %% 2 != 0) { # if clause
    cat('o ')
  } else { # another if-clause
    cat('e ')
  }
}
```
]

--

.pull-left-50[
```{r ifelse3, echo=T}
v <- 1:10
for (i in v) {
  tmp <- 'e ' # set default to even
  if (i %% 2 != 0) { # if clause
    tmp <- 'o ' # change default for odd numbers
  }
  cat(tmp)
}
```
]

--

Each of these three ways are equally good and are mainly the matter of style...

---
name: elif

# Decision taking &mdash; more alternatives

So far, so good, but we were only dealing with 3 alternatives. Let's say that we want to print '?' for zero, 'e' for even and 'o' for an odd number:

```{r if.elseif, echo=T}
v <- c(0:10)
for (i in v) {
  if (i == 0) {
    cat('? ')
  } else if (i %% 2 != 0) { # if clause
    cat('o ')
  } else { # another if-clause
    cat('e ')
  }
}
```
Congratulations! You have just learned the **if-elseif-else** clause.

---
name: switch

# Switch

If-else clauses operate on logical values. What if we want to take decisions based on non-logical values? Well, if-else will still work by evaluating a number of comparisons, but we can also use **switch**:

```{r switch, echo=T}
switch.demo <- function(x) {
  switch(class(x),
         logical = cat('logical\n'),
         numeric = cat('Numeric\n'),
         factor = cat('Factor\n'),
         cat('Undefined\n')
         )
}
switch.demo(x=TRUE)
switch.demo(x=15)
switch.demo(x=factor('a'))
switch.demo(data.frame())
```

---
name: fns

# Functions

Often, it is really handy to re-use some code we have written or to pack together the code that is doing some task. Functions are a really good way to do this in R:

```{r functions1, echo=T,error=T}
add.one <- function(arg1) {
  arg1 <- arg1 + 1
  return(arg1)
}
add.one(1)
add.one()
```

---
name:anatomy_of_a_fn

# Anatomy of a function

A function consists of: *formal arguments*, *function body* and *environment*:

```{r fns.formalsbodyenv, echo=T}
formals(add.one)
body(add.one)
environment(add.one)
environment(sd)
```

---
name: fns_defaults

# Functions &mdash; default values

Sometimes, it is good to use default values for some arguments:

```{r functions2, echo=T, error=T}
add.a.num <- function(arg, num=1) {
  arg <- arg + num
  return(arg)
}
add.a.num(1, 5)
add.a.num(1) # skip the num argument
add.a.num(num=1) # skip the first argument
```

---
name:fns_args

# Functions &mdash; order of arguments

```{r functions3, echo=T}
args.demo <- function(x, y, arg3) {
  print(paste('x =', x, 'y =', y, 'arg3 =', arg3))
}
args.demo(1,2,3)
args.demo(x=1, y=2, arg3=3)
args.demo(x=1, 2, 3)
args.demo(arg3=3, x=1, y=2)
```

<!--  
--

```{r functions4, echo=F, error=F}
args.demo2 <- function(x, arg2, arg3) {
  print(paste('x =', x, 'arg2 =', arg2, 'arg3 =', arg3))
}
#args.demo2(x=1, y=2, ar=3)
```
-->

---
name: variable_scope

# Functions &mdash; variable scope

.pull-left-50[
Functions 'see' not only what has been passed to them as arguments:
```{r fns.varscope, echo=T}
x <- 7
y <- 3
xyplus <- function(x) {
  x <- x + y
  return(x)
}
xyplus(x)
x
```
]

--

.pull-right-50[
Everything outside the function is called **global environment**. There is a special operator `<<-` for working on global environment:

```{r fns.varscope.glob, echo=T}
x <- 1
xplus <- function(x) {
  x <<- x + 1
}
xplus(x)
x
xplus(x)
x
```
]

---
name: fns_ellipsis

# Functions &mdash; the `...` argument

There is a special argument **...** (ellipsis) which allows you to give any number of arguments or pass arguments downstream:

```{r fns.3dots, echo=T, fig.height = 3, fig.width = 6}
# Any number of arguments
my.plot <- function(x, y, ...) { # Passing downstream
  plot(x, y, las=1, cex.axis=.8, ...)
}

{par(mfrow=c(1,2),mar=c(4,4,1,1))
my.plot(1,1)
my.plot(1, 1, col='red', pch=19)}
```

- A function enclosing a function is a **wrapper function**

---
name: ellipsis_trick

# Functions &mdash; the ellipsis argument trick

What if the authors of, e.g. plot.something wrapper forgot about the `...`?

```{r fns.3dots.trick, echo=T, fig.height = 5, fig.width = 5}
my.plot <- function(x, y) { # Passing downstrem
  plot(x, y, las=1, cex.axis=.8, ...)
}
formals(my.plot) <- c(formals(my.plot), alist(... = ))
my.plot(1, 1, col='red', pch=19)
```

---
<!--  
name: lazy_eval

# R is lazy!

In R, arguments are evaluated as late as possible, i.e. when they are needed. This is **lazy evaluation**:

```{r lazy.eval, echo=F, eval = T}
h <- function(a = 1, b = d) {
  d <- (a + 1) ^ 2
  c(a, b)
}
#h()
```

> The above won't be possible in, e.g. C where values of both arguments have to be known before calling a function **eager evaluation**.  
-->
---

name: everything_is_a_fn

# In R everything is a function

Because in R everything is a function

```{r fns.everything_1, echo=F}
`+`
```

--

we can re-define things like this:

--

```{r fns.everything_2, echo=T}
`+` <- function(e1, e2) { e1 - e2 }
2 + 2
```

--

and, finally, clean up the mess...

--

```{r fns.everything_3, echo=T}
rm("+")
2 + 2
```

---
name: infix_fns

# Infix notation

Operators like `+`, `-` or `*` are using the so-called **infix** functions, where the function name is between arguments. We can define our own:

```{r infix, echo=T}
`%p%` <- function(x, y) {
  paste(x,y)
}
'a' %p% 'b'
```

---
name: base_fns

# Base functions

When we start R, the following packages are pre-loaded automatically:

```{r preloaded.packages, echo=T}
# .libPaths() # get library location
# library()   # see all packages installed
search()    # see packages currently loaded
```

Check what basic functions are offered by packages: *base*, *utils* and we will soon work with package *graphics*. If you want to see what statistical functions are in your arsenal, check out package *stats*.

<!-- --------------------- Do not edit this and below --------------------- -->

---
name: end_slide
class: end-slide, middle
count: false

# See you at the next lecture!

```{r, echo=FALSE,child="assets/footer-slide.Rmd"}
```

```{r,include=FALSE,eval=FALSE}
# manually run this to render this document to HTML
#rmarkdown::render("presentation_demo.Rmd")
# manually run this to convert HTML to PDF
#pagedown::chrome_print("presentation_demo.html",output="presentation_demo.pdf")
```