chapter1.Rmd

---
title       : Hello R
description : Basics of R, the amazing statistical programming language. Do not be afraid of the art of programming!

--- type:PureMultipleChoiceExercise lang:r xp:50 skills:1 key:a253f2e756
## What is R?

Welcome to part 1 of **R Short and Sweet**: Hello R.

R is a programming language designed for statistical analysis. R is completely open source and all analysis done with R are reproduciple and easy to share. R is flexible, powerful and includes implementations of the latest research. 

Because of these reasons, R is a very popular language among the scientific community. R is however also widely [used](http://blog.revolutionanalytics.com/2014/05/companies-using-r-in-2014.html) for data analysis and visualisations by companies such as Google, Facebook, Twitter and Reaktor. R is perfect for data science.

Researchers and experts use R to visualize and explore data and implement new statistical methods. The purpose of this short course is to expose you to the basics of programming and data analysis with R.

Choose the correct answer.  

*** =possible_answers
- R is a programming language for statistical computing
- R is open source
- R is widely used for data science
- [All of the above]


*** =feedbacks
- This is true, but not the correct answer
- This is true, but not the correct answer
- This is true, but not the correct answer
- Correct!


--- type:NormalExercise lang:r xp:50 skills:1 key:59231c671b
## Running R code

R code can be written with a simple text editor. R code is just written instructions which the computer can understand. When you want the computer to make an action based on your R code, you must *run* the code (also called *executing*).

Follow the instructions below to complete the exercise.

*** =instructions
- On the right side, the script.R is a text editor which contains R code. When the code is *run*, it gives your computer the instructions to (1) load a dataset and (2) produce a graphic.
- Click on 'Run code' to run the code.
- Click 'Submit Answer' to move on to the next exercise! 

***= hint
- Simply press 'Submit Answer' when you're ready to move forward.


*** =pre_exercise_code
```{r}
# load data
learning2014 <-  read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/learning2014.txt", sep = "\t", header = TRUE)

# Access the ggplot2 package
library(ggplot2)

```

*** =sample_code
```{r}
# This is a text editor which contains R code

# load data
learning2014 <- read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/learning2014.txt", sep = "\t", header = TRUE)

# Access the 'ggplot2' graphics package
library(ggplot2)

# A scatter plot of students attitude and exam points
qplot(attitude, points, col = gender, data = learning2014) + geom_smooth(method = "lm")

```

*** =solution
```{r}
# This is a text editor which contains R code

# load data
learning2014 <-  read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/learning2014.txt", sep = "\t", header = TRUE)

# Access the 'ggplot2' graphics package
library(ggplot2)

# A scatter plot of students attitude and exam points
qplot(attitude, points, col = gender, data = learning2014) + geom_smooth(method = "lm")

```

*** =sct
```{r}
success_msg("Great! Move on to the next exercise.")
```

--- type:NormalExercise lang:r xp:100 skills:1 key:cdaeb146ec
## Basic tools

On your right you see the R editor area - the script.R - and below that the R console. The editor area is just a simple text editor where you write code - just like text.

You can first write code to the editor area and then tell R that you want to execute a line of code where your cursor currently is by pressing `Ctrl + Enter` (`Cmd + Enter` on a mac). Input and output will then appear in the console.

It is also possible to write code directly to the console and use `Enter` to execute, but working with the script area is preferred.

Try it!
  
*** =instructions
- Type "Hello world!" in the editor area. Use quotation marks.
- Press `Ctrl + Enter` to execute your "Hello world!" - code
- Make sure to use a capital "H" and an exclamation mark.
- Click 'Submit Answer' when done.

*** =hint
- Remember to use quotation marks and write the sentence exactly as instructed.


*** =pre_exercise_code
```{r}
# no pec
```


*** =sample_code
```{r}
# This is the R editor!

# A hashtag at the beginning of the line defines the line as a comment

# Write your code below





# Below is the R console, where you will see output
```

*** =solution
```{r}
# This is the R editor!

# A hashtag at the beginning of the line defines the line as a comment

# write your code below
"Hello world!"




# Below is the R console, where you will see output
```

*** =sct
```{r}
test_student_typed("Hello world!", not_typed_msg="Please type 'Hello world!' in the editor.")

test_error()
success_msg("Great work! You have now executed your first line of code :)")
```


--- type:NormalExercise lang:r xp:100 skills:1 key:a6d98b0c0b
## Arithmetics

Let's continue with something simple. R can do amazing things like scrape websites and draw beautiful graphics but it can also do basic calculations. Consider the following arithmetic operators:

- Addition: `+`
- Subtraction: `-`
- Multiplication: `*`
- Division: `/`
- Exponentiation: `^` (or `**`)

The `^` operator raises the number to its left to the power of the number to its right: for example `3^2` is 9. With this knowledge, follow the instructions below to complete the exercise.

*** =instructions
- Study and execute the examples in the R script. (Use `Ctrl + Enter` or `Cmd + Enter`)
- Type `2^5` in the editor and calculate 2 to the power 5.
- When done, click 'Submit Answer'.

*** =hint
- If you have trouble accessing the `^` -sign, you can also use double star `**`.


*** =pre_exercise_code
```{r}
# no pec
```

*** =sample_code
```{r}
# An addition
5 + 5 

# A subtraction
5 - 5 

# A multiplication
3 * 5

 # A division
(5 + 5) / 2 

# Exponentiation



```

*** =solution
```{r}
# An addition
5 + 5

# A subtraction
5 - 5 

# A multiplication
3 * 5

 # A division
(5 + 5) / 2 

# Exponentiation
2 ^ 5

```

*** =sct
```{r}
test_output_contains("2^5", incorrect_msg = "The exponentiation example is not correct. Please write `2 ^ 5` on a new line.")

success_msg("Great work! Head over to the next exercise.")
```

--- type:NormalExercise lang:r xp:100 skills:1  key:aac1b8c5d1
## Objects

Here's where things start to get interesting. In R you can create and operate on things called *objects*. 
An object is something that can store information such as multiple numerical values and names. Once an object is created, it will be stored in memory and the information it contains will be available to you later.

Objects are created using the assign operator: `<-` (< and -). The contents of an object can be printed by typing it's name.


*** =instructions
- Execute the lines that create and operate on `my_character_object` and `my_numeric_object`.
- Assign your name or nickname to `my_name`. Use quotation marks.
- Assign a positive message to yourself to `my_message`. Use quotation marks.
- Click 'Submit Answer'.

*** =hint
- Remember that `Ctrl + Enter` executes a single row.

*** =pre_exercise_code
```{r}
# no pec
```


*** =sample_code
```{r}

# Create an object
my_character_object <- "Hi there!"

# Print the contents of the object
my_character_object

# Create another object
my_numeric_object <- 5 + 5

# Do further calculations with the object
my_numeric_object / 5

# Override the value of an object by assigning a new value to it
my_character_object <- my_numeric_object
my_character_object

# Create character objects my_name and my_message here. Use quotation marks.
my_name <- 
my_message <- 

```

*** =solution
```{r}

# Create an object
my_character_object <- "Hi there!"

# Print the contents of the object
my_character_object

# Create another object
my_numeric_object <- 5 + 5

# Do further calculations with the object
my_numeric_object / 5

# Override the value of an object by assigning a new value to it
my_character_object <- my_numeric_object
my_character_object

# Create character objects my_name and my_message here. Use quotation marks.
my_name <- "Hey You"
my_message <- "You are awsome!"

```

*** =sct
```{r}
test_object("my_name", eval = F, incorrect_msg = "Did you assign your name to `my_name`?")
test_object("my_message", eval = F, incorrect_msg = "Did you assign a message to `my_message`?")

test_error(incorrect_msg = "Did you use quotation marks to assign your name and a message to the objects `my_name` and `my_message`")
success_msg(paste0("Great job ", my_name, ". ", my_message, "!"))
```


--- type:NormalExercise lang:r xp:100 skills:1 key:dc84cbe247
## Functions

In R you operate on objects using *functions*. A function is a special kind of object that uses other objects as inputs, performs operations, and usually outputs a result. The inputs of a function are called *arguments*.  

A Function is *called* by typing it's name and giving it the necessary arguments inside parenthesis. When a function is called, it will perform an action.

R has many functions ready for you to use. Functions are how you're actually going to do all the magic. Here we will do a little bit of magic using data that will become more familiar to you later on.  

*** =instructions
- Create object `student_height` and compute the mean height of students. Don't worry about the `$` -sign for now, we will get to that later.  
- Create object `student_age` and compute the mean age of students  
- When done, click 'Submit Answer'  

*** =hint
- Use the function `mean()` and the object `student_age` like in the example on line 7 of script.R.


*** =pre_exercise_code
```{r}
students2014 <- read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/JYTOPKYS-data.txt", sep="\t", header=TRUE)

# keep a couple background variables
students2014 <- students2014[,c("sukup","toita","ika","pituus","kenka","kone")]

# recode kone -variable NA values as factor levels
students2014$kone <- addNA(students2014$kone)

# choose rows without missing values
students2014 <- students2014[complete.cases(students2014),]

# integers to numeric
students2014$ika <- as.numeric(students2014$ika)
students2014$pituus <- as.numeric(students2014$pituus)
students2014$kenka <- as.numeric(students2014$kenka)

```

*** =sample_code
```{r}
# students2014 data is available

# Create object student_height
student_height <- students2014$pituus

# Compute the average height of the students
mean(student_height)

# Create object student_age
student_age <- students2014$ika

# Compute the average age of the students




```

*** =solution
```{r}
# students2014 data is available

# Create object student_height
student_height <- students2014$pituus

# Compute the average height of the students
mean(student_height)

# Create object student_age
student_age <- students2014$ika

# Compute the average age of the students
mean(student_age)



```

*** =sct
```{r}
test_output_contains("mean(student_age)", incorrect_msg = "Please use the `mean()` function to compute the mean of student_age.")

test_error()
success_msg("Excellent! You are making great progress.")
```


--- type:NormalExercise lang:r xp:100 skills:1 key:dc76ff838a
## Good arguments

During this course you will operate on R's ready-made functions. As you already saw, functions take objects as their arguments and then perform actions using the objects. Using a function is called *calling* it.

Functions usually have more than one possible argument. Some of the arguments can have default values and others need to be specified. The arguments have names, which can (and often should) be used when specifying their values. The recommended style is to specify all but the first argument by name, when calling a function.

Multiple arguments are separated with a comma.  

*** =instructions
- Study and execute the example codes where the function `head()` is used to explore the first couple observations of the `students2014` dataset.
- Using the assign operator `<-`, create object `first_ten_students` by calling `head()` with `n = 10`.

*** =hint
- Directly assign the output of `head()` to `first_ten_students` to create the object
- The answer is of the form: `first_ten_students <- head(arguments_here)`
- Remember to separate function arguments with a comma



*** =pre_exercise_code
```{r}
# load data from web
students2014 <- read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/JYTOPKYS-data.txt", sep="\t", header=TRUE)
# keep a couple background variables
students2014 <- students2014[,c("sukup","toita","ika","pituus","kenka","kone")]
# recode kone variables missing values as factor levels
students2014$kone <- addNA(students2014$kone)
# keep only rows without missing values
students2014 <- students2014[complete.cases(students2014),]
# integers to numeric
students2014$ika <- as.numeric(students2014$ika)
students2014$pituus <- as.numeric(students2014$pituus)
students2014$kenka <- as.numeric(students2014$kenka)

```


*** =sample_code
```{r}
# students2014 is available

# Use the function head() on the object students2014
head(students2014, n = 4)

# Argument 'n' of head() has a default value 6
head(students2014)

# These calls are identical. Try them.
head(students2014, n = 3) # recommended style
head(students2014, 3)     # style usually not recommended
head(n = 3, students2014) # style not recommended

# Save the first ten observations of the data to an object
first_ten_students <- 


```

*** =solution
```{r}
# students2014 is available

# Use the function head() on the object students2014
head(students2014, n = 4)

# Argument 'n' of head() has a default value 6
head(students2014)

# These calls are identical. Try them.
head(students2014, n = 3) # recommended style
head(students2014, 3)     # style usually not recommended
head(n = 3, students2014) # style not recommended

# Save the first ten observations of the data to an object
first_ten_students <- head(students2014, n = 10)


```

*** =sct
```{r}
test_error(incorrect_msg = "Your code seems to produce an error. Did you create the object `first_ten_students` as instructed?")

test_object("first_ten_students")

success_msg("Great job!")
```


--- type:NormalExercise lang:r xp:100 skills:1 key:a8d5dff737
## Data frames

In R, the basic idea is to use *functions* to operate on objects. The most common object to operate on is the `data frame` object, which stores data in tabular form.  
The columns in data frames are vectors. Data frames can contain multiple vectors with different data types. You will soon learn more about vectors and data types.

Here you will get to apply some functions that are helpful for inspecting data: `head()` and `str()`. You will also learn how to access the columns of a data frame using the $-sign.  

*** =instructions
- Execute the function `head()` and see the results
- Inspect the data types in the `students2014` data with the function `str()`
- Note that `students2014$ika` prints out all the ages of the students in `students2014`
- Use the $-sign to access the students shoe size (column `kenka`) in `students2014` data

*** =hint
- The data is stored in object `students2014`

*** =pre_exercise_code
```{r}
students2014 <- read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/JYTOPKYS-data.txt", sep="\t", header=TRUE)

# keep a couple background variables
students2014 <- students2014[,c("sukup","toita","ika","pituus","kenka","kone")]

# recode kone -variable NA values as factor levels
students2014$kone <- addNA(students2014$kone)

# choose rows without missing values
students2014 <- students2014[complete.cases(students2014),]

# integers to numeric
students2014$ika <- as.numeric(students2014$ika)
students2014$pituus <- as.numeric(students2014$pituus)
students2014$kenka <- as.numeric(students2014$kenka)
```

*** =sample_code
```{r}
# students2014 is available

# Let's view the first 6 students from the students2014 data
head(students2014)

# View the structure of students2014
str(students2014)

# You can access the variables in the students2014 data by using the $-sign
students2014$ika

# Access the shoe sizes of the students


```

*** =solution
```{r}
# students2014 is available

# Let's view the first 6 students from the students2014 data
head(students2014)

# View the structure of students2014
str(students2014)

# You can access the variables in the students2014 data by using the $-sign
students2014$ika

# Access the shoe sizes of the students
students2014$kenka
```

*** =sct
```{r}
test_output_contains("students2014$kenka", incorrect_msg = "Did you use the $-sign to access the shoe size variable?")

# test if the students code produces an error
test_error()

# Final message the student will see upon completing the exercise
success_msg("Well done! You are really getting the hang of it.")

```

--- type:NormalExercise lang:r xp:100 skills:1 key:792094dea8
## Data types (1)

In these next exercises you wil learn about the data types in R. You will also get familiar with vectors and their usage. What do data types and vectors have to do with each other? A lot, you'll see! 

There are different data types in R. The most commonly used are:

- Numbers and decimal values are called **numeric**
- Text or character values are called **characters**
- [Boolean values](https://en.wikipedia.org/wiki/Boolean_data_type) (`TRUE` or `FALSE`) are called **logical**

When creating character values, one needs to use quotation marks (both `' '` and `" "` will work). For example `"Statistics<3"` would be a character value in R. Numeric and boolean values do not need quotation marks. Boolean values `TRUE` and `FALSE` can be abbreviated with `T` and `F`.  

You can use the function `str()` (str is short for structure) to find out what data type the object is.

*** =instructions
- Create character object `my_character` by assigning your initials in it.
- Assign the number 10.5 to `my_numeric`. Note that the decimal separator in R is dot instead of comma. 
- Create the object `my_logical` by executing the line. Note that with boolean values, no quotation marks are needed.
- Change the value of `my_logical` to `TRUE`
- Inspect the data types of the objects with `str()`.

*** =hint
- When creating a character object, remember to use quotation marks.
- Dot is the decimal mark in R:  `2.5` is decimal number but `2,5` means a different thing!
- Remember that `Ctrl + Enter` executes a single row.
- You can use `str()` by putting the object name inside the parenthesis.

*** =pre_exercise_code
```{r}
```

*** =sample_code
```{r}
# Create three objects with different data types
my_character <-
my_numeric <-
my_logical <- FALSE

# See how each object looks with the function str()




```

*** =solution
```{r}
# Create three objects with different data types
my_character <- "A.B.C."
my_numeric <- 10.5
my_logical <- TRUE

# See how each object looks with the function str()
str(my_character)
str(my_numeric)
str(my_logical)

```

*** =sct
```{r}
test_object("my_character", eval=FALSE, incorrect_msg = "Did you assign your initials to `my_character`?")
test_object("my_numeric", incorrect_msg="Did you assign the correct value to `my_numeric`?")
test_object("my_logical", incorrect_msg="Did you change the value of `my_logical`?")

test_output_contains("str(my_character)", incorrect_msg = "Did you use `str()` on `my_character`?")  
test_output_contains("str(my_numeric)", incorrect_msg = "Did you use `str()` on `my_numeric`?")  
test_output_contains("str(my_logical)", incorrect_msg = "Did you use `str()` on `my_logical`?")

# test if the students code produces an error
test_error()

# Final message the student will see upon completing the exercise
success_msg("You're making great progress, well done!")
```

--- type:NormalExercise lang:r xp:100 skills:1 key:02be1c797a
## Data types (2)

Another one of R's data types is called factor. Factors contain numbers, but for every number there is a character value associated to it. A variable measured by the [Likert scale](https://en.wikipedia.org/wiki/Likert_scale) could for example be coded as a factor: the values are numbers from 1 to 5, but the numbers also have words attached to them such as:

- "Strongly disagree" = 1
- "Strongly agree" = 5

In R it is also possible to create factors from numerical objects by using the function `cut()`, which splits a variable into categories. It has a mandatory argument `breaks`, which defines the cutting points of the categories.  

*** =instructions
- Create objects `student_age` and `student_age_cut`
- Use `str()` to inspect `student_age_cut`
- Use `head()` to print the first six values of `student_age`
- Use `head()` to print the first six values of `student_age_cut`


*** =hint
- Give the object `student_age_cut` as the first argument to `str()` and `head()`.

*** =pre_exercise_code
```{r}
students2014 <- read.table("http://www.helsinki.fi/~kvehkala/JYTmooc/JYTOPKYS-data.txt", sep="\t", header=TRUE)

# keep a couple background variables
students2014 <- students2014[,c("sukup","toita","ika","pituus","kenka","kone")]

# recode kone -variable NA values as factor levels
students2014$kone <- addNA(students2014$kone)

# choose rows without missing values
students2014 <- students2014[complete.cases(students2014),]

# integers to numeric
students2014$ika <- as.numeric(students2014$ika)
students2014$pituus <- as.numeric(students2014$pituus)
students2014$kenka <- as.numeric(students2014$kenka)
```

*** =sample_code
```{r}
# students2014 is available

# Let's access the (numerical) age vector of the students2014 and save it to another object.
student_age <- students2014$ika

# Let's use the cut()-function to cut the variable in categories
student_age_cut <- cut(student_age, breaks = c(15, 25, 35, 100))

# Inspect the data type of student_age_cut


# Print the first 6 elements of student_age and student_age_cut



```

*** =solution
```{r}
# students2014 is available

# Let's access the (numerical) age vector of the students2014 and save it to another object.
student_age <- students2014$ika

# Let's use the cut()-function to cut the variable in categories
student_age_cut <- cut(student_age, breaks = c(15, 25, 35, 100))

# Inspect the data type of student_age_cut
str(student_age_cut)

# Print the first 6 elements of student_age and student_age_cut
head(student_age)
head(student_age_cut)


```

*** =sct
```{r}

test_function("str", args="object", incorrect_msg = "Did you use the `str()` to look at the object 'student_age_cut'?")

test_output_contains("head(student_age)", incorrect_msg = "Did you use `head()` and look at the first six elements of `student_age`?")
test_output_contains("head(student_age_cut)", incorrect_msg = "Did you use `head()` to look at the first six elements of `student_age_cut`?")

# test if the students code produces an error
test_error()

# Final message the student will see upon completing the exercise
success_msg("Good work!")

```


--- type:NormalExercise lang:r xp:100 skills:1 key:dc3cc379e2
## Vectors

A vector is an object containing multiple elements of the same data type. Vectors are quite important in R. The columns of a data frame (such as `student2014`) are vectors.

You can create your own vectors by combining values of the same data type, using the function `c()`.  

*** =instructions
- See and execute the examples on how to create a vector with `c()`.
- Create a character vector `character_vector`.
- Create a vector `logical_vector` with boolean values `TRUE, FALSE, TRUE, FALSE`.
- Print the contents of `logical_vector`.

*** =hint
- When creating boolean values, no quotation marks are needed.
- You can print the contents of an object by typing it's name.


*** =pre_exercise_code
```{r}
```


*** =sample_code
```{r}
# Here we create a vector with numeric elements
c(2, 3, 4, 5)

# Another one
c(0.1, 0.2, 5.84, 0.7)

# Let's create one with characters and save it to a object
character_vector <- c("a", "b", "c", "d")

# Create a logical vector and print it



```

*** =solution
```{r}
# Here we create a vector with numeric elements
c(2, 3, 4, 5)

# Another one
c(0.1, 0.2, 5.84, 0.7)

# Let's create one with characters and save it to a object
character_vector <- c("a", "b", "c", "d")

# Create a logical vector and print it
logical_vector <- c(TRUE, FALSE, TRUE, FALSE)
logical_vector

```

*** =sct
```{r}

test_object("logical_vector", incorrect_msg = "Did you create `logical_vector` with same values as instructed?")
test_output_contains("logical_vector", incorrect_msg = "Did you print the contents of `logical_vector`?")
test_error()

# Final message the student will see upon completing the exercise
success_msg("Great work!")

```