programming_basics_20190916_152_chang.Rmd

---
title: "R Notebook"
output: html_notebook
---

---
title: "R Notebook"
output: html_notebook
---

---
title: "R Notebook"
output: html_notebook
---

# 4.4 For-loops

The formula for the sum of the series 1 to n is n(n+1)/2. What if we weren’t sure that was the right function? How could we check? Using what we learned about functions we can create one that computes the Sn:
```{r}
compute_s_n <- function(n){
  x <- 1:n
  sum(x)
}
```

How can we compute Sn for various values of n, say n=1,...,25? Do we write 25 lines of code calling `compute_s_n`? No, that is what for-loops are for in programming. In this case, we are performing exactly the same task over and over, and the only thing that is changing is the value of n. For-loops let us define the range that our variable takes (in our example n=1,...,10), then change the value and evaluate expression as you loop.

Perhaps the simplest example of a for-loop is this useless piece of code:
```{r}
for(i in 1:5){
  print(i)
}
```

Here is the for-loop we would write for our Sn example:
```{r}
m <- 25
s_n <- vector(length = m) #create an empty vector
for(n in 1:m){
  s_n[n] <- compute_s_n(n)
}
```
In each iteration n=1, n=2, etc…, we computeSn and store it in the  
nth entry of `s_n`.

Now we can create a plot to search for a pattern:
```{r}
n <- 1:m
plot(n, s_n)
```

If you noticed that it appears to be a quadratic, you are on the right track because the formula is n(n+1)/2, which we can confirm with a table:
```{r}
head(data.frame(s_n = s_n, formula = n*(n+1)/2))
```

We can also overlay the two results by using the function lines to draw a line over the previously plotted points:
```{r}
plot(n, s_n)
lines(n, n*(n+1)/2)
```

# 4.5 Vectorization and functionals

Although for-loops are an important concept to understand, in R we rarely use them. As you learn more R, you will realize that vectorization is preferred over for-loops since it results in shorter and clearer code. We already saw examples in the Vector Arithmetic Section. A vectorized function is a function that will apply the same operation on each of the vectors.
```{r}
x <- 1:10
sqrt(x)
y <- 1:10
x*y
```

To make this calculation, there is no need for for-loops. However, not all functions work this way. For instance, the function we just wrote, `compute_s_n`, does not work element-wise since it is expecting a scalar. This piece of code does not run the function on each entry of `n`:
```{r}
n <- 1:25
compute_s_n(n)
```

Functionals are functions that help us apply the same function to each entry in a vector, matrix, data frame or list. Here we cover the functional that operates on numeric, logical and character vectors: `sapply`.

The function `sapply` permits us to perform element-wise operations on any function. Here is how it works:
```{r}
x <- 1:10
sapply(x, sqrt)
```

Each element of `x` is passed on to the function `sqrt` and the result is returned. These results are concatenated. In this case, the result is a vector of the same length as the original `x`. This implies that the for-loop above can be written as follows:
```{r}
n<-1:25
s_n<-sapply(n,compute_s_n)
plot(n,s_n)
```

Other functionals are `apply`, `lapply`, `tapply`, `mapply`, `vapply`, and `replicate`. We moslty use `sapply`, `apply`, and `replicate` in this book, but we recommend familiarizing yourselves with the others as they can be very useful.

# 4.6 Exercises

1. What will this conditional expression return?
```{r}
x<-c(1,2,-3,4)

if(all(x>0)){
  print("All positives")
} else{
  print("Not all positives")
}
```
<Not all positives>

2. Which of the following expressions is always `FALSE` when at least one entry of a logical vector `x` is TRUE?
A. all(x)

B. any(x)

C. any(!x)

<D. all(!x)>

3. The function `nchar` tells you how many characters long a character vector is.

Write a line of code that assigns to the object `new_names` the state abbreviation when the state name is longer than 8 characters.
```{r}
library(dslabs)
data(murders)
new_names<-murders$abb[nchar(murders$state)>8]
new_names
```

4. Create a function `sum_n` that for any given value, say n, computes the sum of the integers from 1 to n (inclusive). Use the function to determine the sum of integers from 1 to 5,000.
```{r}
sum_n<-function(n){
  sum(1:n)
}

sum_n(5000)
```

5. Create a function `altman_plot` that takes two arguments, x and y, and plots the difference against the sum.
```{r}
altman_plot<-function(x,y){
  plot(x+y,abs(x-y))
}
altman_plot(c(5,2,6,7),c(7,3,9,11))
```

6. After running the code below, what is the value of `x`?
```{r}
x <- 3
my_func <- function(y){
  x <- 5
  y+5
}
x
```
<3>

7. Write a function compute_s_n that for any given n computes the sum Sn=1^2+...+n^2. Report the value of the sum when n=10.
```{r}
s<-vector(length=30)
compute_s_n<-function(n){
  x<-1:n
  sum(x*x)
}
compute_s_n(10)
```

8. Define an empty numerical vector `s_n` of size 25 using `s_n <- vector("numeric", 25)` and store in the results of S1,S2,…S25 using a for-loop.
```{r}
s_n<-vector("numeric",25)
for(i in 1:25){
  s_n[i]<-compute_s_n(i)
}
```

9. Repeat exercise 8, but this time use `sapply`.
```{r}
x<-1:25
sapply(x,compute_s_n)
```

10. Repeat exercise 8, but this time use `map_dbl`.
```{r}
library(purrr)
map_dbl(x,compute_s_n)
```

11. Plot Sn versus n. Use points defined by n=1,...,25.
```{r}
plot(x,s_n)
```

12. Confirm that the formula for this sum is Sn=n(n+1)(2n+1)/6.
```{r}
identical(s_n,x*(x+1)*(2*x+1)/6)
```