Practice makes perfect

Display the sum of the numbers one to five divided by five.

# There are numerous ways to do this task.
# You may want to start with the display function
cat(...)

# Do not forget to close the brackets before dividing
cat((1 + 2 + 3 + 4 +5) ... )

cat((1+2+3+4+5)/5)

The average (aka. sample mean) is computed in this way, i.e.  \[\bar{x} = \frac{1}{n}\sum_{i=1}^n x_i = \frac{x_1+x_2+\dots+x_n}{n}\]

Display the text: “The golden ratio is:” and concatenate it with the calculation \(\frac{1+\sqrt{5}}{2}\). By the way, the background to the golden ratio is intruiging.

cat("The golden ratio is: ", (1+sqrt(5))/2)

Scalars

In the previous exercises scalars were used. Now we will use them via variable names.

a = 1; b = 2; # this is a comment: declaration
c = a + b     # addition
c             # show result   

Let us analyse the above code. The first line assigns values to the variables \(a\) and \(b\). The first command is to assign the value 1 to a via a=1. In R it is very common to use <- as assignment operator. Try it - replace all = with <- in the above code. You can even assign variables from right to left, e.g. a+b -> c, which “feels” really strange if you have used other programming languages. The second command is b=2. Commands in the same line are seperated by a semicolon ;. We have added a comment at the end of line 1. Comments are identified with a hashtag #, and they are not computed.

Vectors

x = c(1,2,3) # easiest way
# or using the previous variables 
a = 1; b = 2; c = a + b;
x = c(a,b,c)

x = c(1,2,3) 
cat('length = ', length(x), '\n')
cat('x1 = ', x[1], ', x2 = ', x[2], 'etc.')

x <- c(11,22,33,44,55) 
I <- c(2,3,2,5)  # index vector
x[I]

x = c(1,2,3) 
y = c(4,5,6)
x + y

x = c(1,2,3) 
t(x)
t(t(x))

x = c(1,2,3) 
y = c(4,5,6)
x * y

x = c(1,2,3) 
y = c(4,5,6)
x %*% y

Practice makes perfect

Create a vector \(y\) with elements one to ten using the colon operator :, then add the second and ninth element. Try to break up your solution approach in little chunks. First write 1:10 and press Run Code, then assign it to \(y\). At last calculate \(y_2+y_9\) (see hints).

y = 1:10

y[2]+y[9]

Assume you have two vectors \(u = \begin{bmatrix}5&2\end{bmatrix}^\intercal\) and \(v = \begin{bmatrix}2&4\end{bmatrix}^\intercal\).

Vector addition.

What is \(u+v\)?

u = c(5,2); v=c(2,4)

u = c(5,2); v=c(2,4)
u+v

How can you double the size of vector \(\begin{bmatrix}7&6\end{bmatrix}\)?

# Use scalar multiplication, or add the same vector twice
2*c(7,6)

Assume \(u=\begin{bmatrix}1&2&3\end{bmatrix}\) and \(v=\begin{bmatrix}2&1&\frac{1}{3}\end{bmatrix}\). What is the Hadamard product \(u\odot v\)?

u = c(1,2,3); v=c(2,1,1/3)

u = c(1,2,3); v=c(2,1,1/3)
u*v

Given are \(u=\begin{bmatrix}1&2&3\end{bmatrix}\) and \(e=\begin{bmatrix}1&1&1\end{bmatrix}\). What is the dot product \(u\cdot e\)?

u = c(1,2,3); e=c(1,1,1)

u = c(1,2,3); e=c(1,1,1)
u%*%e

Beautiful side effect - the dot product of a vector \(u\) with a one-vector \(e\) is just the sum of the vector elements, i.e. \(u \cdot e = \sum_{i=1}^n u_i\)

Matrices

x = c(1,2,3); y = c(4,5,6)
A = cbind(x,y) # column bind
B = rbind(x,y) # row bind
A;B

Another way to create \(A\) is by using the matrix function with the input ncol = 2.

A = matrix(c(1,2,3, 4,5,6), ncol = 2)

Now it is interesting to access individual elements of the matrix. For instance, assume you want to return the element located in row 3 and column 2.

A[3,2]

Let’s expand the matrix to make it more interesting.

B = cbind(A,A)
B

##      [,1] [,2] [,3] [,4]
## [1,]    1    4    1    4
## [2,]    2    5    2    5
## [3,]    3    6    3    6

Let’s return the second row and third column.

B[2,]

## [1] 2 5 2 5

B[,3]

## [1] 1 2 3

Let’s return the second and fourth column of \(B\).

B[,c(2,4)]

Practice makes perfect

Determine the type of 123.45:

typeof(123.45)

Extract the first character of str.

str = 'Data Analytics'

str = 'Data Analytics'
substr(str,1,1)

Extract the last two characters of str using nchar().

str = 'Data Analytics'

str = 'Data Analytics'
substr(str,nchar(str)-1,nchar(str))

Data-frames

Probably the most important data structure is the data.frame. In the previous section we created several vectors with different basic data types. Now we can put them together in a data.frame.

x = c(1,2,3)
b = c(TRUE,FALSE,TRUE)
s = c('one','two','three')
c = c(1+0i,1+1i,-1+0i)
D = data.frame(x,b,s,c)
D

This is similar to a matrix. However, a matrix only contains elements of one type. We observe that each column vector must have the same length.

cat(length(x),length(b),length(s),length(c))

Accessing elements can be achieved in the same way as in matrices. For instance let us extract the element in the second raw and third column.

D[2,3]

Similarly to matrices rows and columns can be extracted, e.g. second raw and third column.

D[2,]; D[,3]

Let us have a look at another example. Assume you have got several customers and information about them: create the following data frame.

customer <- c('Wolfgang','Eleanor','Vikas','Patrick')
salary   <- c(100,90,120,60)
years    <- c(10,3,8,1)
df <- data.frame(customer,salary,years)
df

This data frame has four rows aka. observations and three columns aka. variables or features.

A feature can be extracted from a data frame using the access operator $. Let us extract all customers from the data frame.

df$customer

An observation can be obtained using square-brackets:

df[2,]

Lists

Lists are a sequence of elements. For instance,

L = list(a_number=1, words=c('one','two'), binvec = c(TRUE,FALSE,TRUE))

Elements in a list are accessed differently to data-frames using [[]]. For instance,let us get the second element in the list, which is vector s.

L[[2]]

In a certain way a data.frame is a special list, where all elements are vectors with the same length.

It is possible to access column vectors in lists and data-frames by their name, using the list subset operator $. The function names() returns the names as expected.

names(L)

For instance, let us return x in D using $.

D$x

cars = mtcars
nrow(cars)

cars = mtcars
cars

library(help = "datasets")
# help(mtcars) # get more information (opens in new window)

# start with
mtcars$mpg

# for the average use
# mean(...)

# start with the previous challenge
mean(mtcars$mpg)

# figure out each mpg
mtcars$mpg > mean(mtcars$mpg)

# try 
rownames(mtcars)

# put it all together using logical indizes
rownames(mtcars)[mtcars$mpg > mean(mtcars$mpg)]

Practice makes perfect

Create a generic, default and specific purchase function for the customer class, which allows a customer to buy a car.

# generic method
purchased <- function(obj) { UseMethod("purchase")}

# try this for any class
purchased <- function(obj, purchased_object) {
  obj$purchased_object <- purchased_object
  cat("The object:", obj$purchased_object,"was purchased.\n")
  return(obj)
}

# use this for the customer class
purchased <- function(obj, car) {
  obj$car <- car
  cat(obj$name, "purchased a", obj$car,".\n")
  return(obj)
}
wolfi <- purchased(wolfi,"MG ZS EV")

A class consists out of attributes (attributes(c1)) and methods. The above introduced S3 class system is probably the most popular one. Generally, object oriented programming (OOP) attempts to provide coding with a more natural language. For instance, “Wolfgang purchased an BMW”, translates into wolfi <- purchased(wolfi,"BMW").

However, there is another object oriented programming approach in R, known as R6. This one is more closely related to traditional programming languages such as C# and Java. Please see Hadley’s R6 and Chang’s documentation for more details. The above example’s translation becomes a bit more natural wolfi$purchased("BMW").

library(R6)
Customer <- R6Class(
  classname = "Customer",
  public = list(
    name = '', salary = 0, car = '',
    initialize = function(name = '', salary = 0) {
      self$name   = name; self$salary = salary
    },
    purchased = function(car) {
      self$car = car
      cat(self$name, "purchased a",self$car,"\n")
    }
))
wolfi <- Customer$new("Wolfgang",100)
wolfi$purchased("BMW")

Acknowledgment

This tutorial was created using RStudio, R, rmarkdown, and many other tools and libraries. The packages learnr and gradethis were particularly useful. I’m very grateful to Prof. Andy Field for sharing his discovr package, which allowed me to improve the style of this tutorial and get more familiar with learnr. Allison Horst wrote a very instructive blog “Teach R with learnr: a powerful tool for remote teaching”, which encouraged me to continue with learnr. By the way, I find her statistic illustrations amazing.