Introduction to R base. First operations and databases

Practical workbooks of Data Programming in Master in Computational Social Science (2024-2025)

1 Introduction to R and R Studio

1.1 Intro aspects

1.1.1 Requirements

For the course, the only requirements will be:

1. Internet connection (to download some data and packages).

2. Install R: it will be our language. We will download it (for free) from https://cran.r-project.org/

3. Install RStudio from https://posit.co/download/rstudio-desktop/

1.1.2 R vs RStudio

We will program as we write:

• We will need a grammar, a language (R)

• And an environment, such as Word (RStudio) to write it

1.1.3 Installing R

The R language will be our grammar and spelling (our rules of the game)

• Step 1: go to https://cran.r-project.org/ and select your operating system.

• Step 2: for Mac, simply click on the .pkg file, and open it once downloaded. For Windows systems, we need to click on install R for the first time and then on Download R for Windows. Once downloaded, open it like any installation file.

• Step 3: open the installation executable.

Warning

Whenever you need to download something from CRAN (either R itself or a package), make sure you have an internet connection.

1.1.3.1 First operations

To check the installation, after opening R, you should see the R GUI (Graphical User Interface) with a white screen similar to this (console).

First code: we will assign the value 1 to a variable called a (we will write the code in the console and press “enter”). Then we will do the sum a + b.

a <- 1
b <- 2
a + b

[1] 3

Note that…

In the console, a number [1] appears: it’s simply an element counter (like counting rows in Word)

1.1.4 Installing R Studio

RStudio will be the Word we will use to write (what is known as an IDE: Integrated Development Environment).

• Step 1: go to the official RStudio website (now called Posit) and select the free download.

• Step 2: select the executable that appears according to your operating system.

• Step 3: after downloading the executable, open it like any other and let the installation finish.

1.1.4.1 RStudio Organization

When you open RStudio you will likely have three windows:

• Console: is the name for the large window that takes up most of your screen. Try writing the same code as before (the sum of the variables) in it. The console is where we will execute commands and display results.

• Environment: the small screen (you can adjust the margins with the mouse to your liking) that we have in the top right corner. It will show us the variables we have defined.

• Multi-purpose panel: the window at the bottom right will be used to look for function help, as well as to visualize plots.

1.1.5 What is R? Why R?

R is the evolution of the work of Bell Laboratories with the S language, which was brought into the open-source world by Ross Ihaka and Robert Gentleman in the 1990s. The version R 1.0.0 was released on February 29, 2000. R is the statistical language par excellence, created by and for statisticians, with 6 fundamental advantages over Excel, SAS, Stata, or SPSS:

• Programming language: the obvious → replicable analysis

• Free: the philosophy of the R community is to share code under copyleft → ethical use of spending and algorithms

• Open-source software: not only is it free, but it also allows free access to others’ code, even to the source code itself → flexibility and transparency (Free and Open Source Software FOSS)

• Modular language: we have installed the minimum, but there are codes from other people that we can reuse (almost 20,000 packages) → time saving and immediate innovation

• High-level language: facilitates programming (like Python) → lower learning curve

• Community and employability: along with Python, it is the most used language in the field of statistics and data science in research, teaching, companies (Línea Directa, Mapfre, Telefónica, Orange, Apple, Spotify, Netflix, El País, Civio, HP, etc.) and public organizations (ISCIII, CNIC, CNIO, INE, IGN, CIS, CEO, DGT, AEMET, RTVE, etc.)

1.1.5.1 Why programming?

• Automate → it will allow you to automate recurring tasks.

• Replicability → you will be able to replicate your analysis in the same way every time.

• Flexibility → you will be able to adapt the software to your needs.

• Transparency → to be audited by the community.

1.1.5.2 Fundamental Idea: R packages

One of the key ideas of R is the use of packages: codes that other people have implemented to solve a problem

• Installation: we download the codes from the web (we need internet) → buy a book, only once (per computer)

install.packages("ggplot2")

• Loading: with the package downloaded, we indicate which packages we want to use each time we open RStudio → take the book off the shelf

library(ggplot2)

Once installed, there are two ways to use a package (take it off the shelf)

• Whole package: with library(), using the package name without quotes, we load the whole book into the session

library(ggplot2)

• Specific functions using `package::function+ we indicate that we only want a specific page of that book

ggplot2::geom_point()

1.1.6 You will be wrong

During your learning, it will be very common for things not to work out on the first try → you will be wrong. It will not only be important to accept it but also to read the error messages to learn from them.

• Error messages: preceded by “Error in…” and will be those failures that prevent execution

"a" + 1 

Error in "a" + 1: non-numeric argument to binary operator

• Warning messages: preceded by «Warning in…» they are the (possible) more delicate errors as they are inconsistencies that do not prevent execution

# Ejecuta la orden pero el resultado es NaN, **Not A Number**, un valor que no existe
sqrt(-1)

Warning in sqrt(-1): NaNs produced

[1] NaN

1.1.7 Scripts (.R files)

A script will be the document in which we program, our .doc file (here with a .R extension) where we will write the commands. To open our first script, click on the menu in File < New File < R Script.

Be careful

It’s important not to overuse the console: everything you don’t write in a script, when you close, will be lost.

Be careful

R is case-sensitive: it is sensitive to uppercase and lowercase, so x and X represent different variables.

Now we have a fourth window: the window where we will write our codes. How do we run it?

1. Write the code to be executed.

2. Save the .R file by clicking on Save current document.

3. The code does not execute unless we indicate it. We have three options to run a script:

• Copy and paste into the console.
• Select lines and press Ctrl+Enter
• Enable Source on Save next to save: not only saves but also executes the entire code.

1.1.8 Organizing in projects in RStudio

Just as we usually work organized by folders on the computer, in RStudio we can do the same to work efficiently by creating projects.

A project will be a “folder” within RStudio, so our root directory will automatically be the project folder itself (allowing us to switch from one project to another using the top right menu). We can create one in a new folder or in an existing folder.”

1.2 💻 It’s your turn

Exercise 1

📝 Create in your computer a folder of the subject and create inside it the RStudio project: it is there where you are going to save everything that we will do along this course, after creating the project you will have an R Project file. Then create in this folder two subfolders: data (this is where you will save the different datasets that we will use) and scripts (this is where you will save the .R files of each class).

Exercise 2

📝 Inside the project create a script Exercises-class1.R (inside the scripts folder). Once created, define in it a variable named a and whose value is -1. Execute the code in the (three) ways explained before.

Code

a <- -1

Exercise 3

📝 Add below another line to define a variable b with the value 5. Then save the multiplication of both variables. Execute the code as you want.

Code

b <- 5
a * b # without saving it
mult <- a * b # save it

Exercise 4

📝 Modify the code below to define two variables c and d, with values 3 and -1. Then divide the variables and save the result.

c <- # you should assign 3
d <- # you should assign -1

Code

c <- 3
d <- -1
c / d
div <- c / d

Exercise 5

📝 Assign to x a positive value and then compute its square root; assign to y a negative number and compute its absolute value using abs().

Code

x <- 5
sqrt(x)

y <- -2
abs(y)

Note that…

Commands like sqrt(), abs() or max() are what we call functions: lines of code that we have “encapsulated” under a name, and given some input arguments, execute the commands (a sort of shortcut). In the functions the arguments will ALWAYS be enclosed in parentheses

Exercise 6

📝 Using the variable x already defined, complete/modify the code below to store in a new variable z the result stored in x minus 5.

z <- ? - ? # complete the code
z

Code

z <- x - 5
z

Exercise 7

📝 Define an x variable and assign it the value -1. Define another y and assign it the value 0. Then perform the operations a) x by y; b) square root of x. What do you get?

Code

x <- -1
y <- 0

x / y
sqrt(x)

Exercise 8

📝 Write the code below in your script. Why do you think it doesn’t work?

x <- -1
y <- 0

X + y

Error in eval(expr, envir, enclos): object 'X' not found

2 First steps in R (base)

What data type can we have in each cell of a table?

• Cell: an individual piece of data of a specific type.
• Variable: concatenation of values of the same type (vectors in R).
• Matrix: concatenation of variables of the same type and length.
• Table: concatenation of variables of different types but the same length
• List: concatenation of variables of different types and different lengths :::

Before we continue, it’s important to know something as soon as possible: starting with programming can be frustrating. Just like when learning a new language, the first obstacle is not so much what to say but how to say it correctly. The same goes for R, so let’s standardize our programming style as much as possible to avoid future errors.

• Tip 1: assignment, evaluation, and comparison are not the same. If you’ve noticed in R, we use <- to assign values to variables. We use = to evaluate function arguments and == to check if two elements are equal.

x <- 1 # asign
x = 1 # evaluation
x == 1 # comparison

• Tip 2: program like you write. Just like when writing in Spanish, get used to incorporating spaces and line breaks to avoid making your code hard to read (it’s a good practice, not a requirement, because R does not process spaces).

x <- 1 # optimal
x<-1 # meh
x<- 1 # worst (make up your mind)

• Tip 3: don’t be chaotic, standardize names. Always get used to naming variables consistently. The only requirement is that they must always start with a letter (and without accents). The most recommended form is snake_case.

variable_in_snake_case
anotherHarderToReadFormat
there.are.people.who.use.this
Even_People_Here.Confusing_That_Do_Not_Deserve_Our_ATTENTION

• Tip 4: make reading and writing easier, set limits. In Tools < Global Options, you can customize some options in RStudio. In Code < Display, you can set Show margin to display an “imaginary” margin (not interacting with the code) to “force” you to make line breaks.

• Tip 5: the tab key is your best friend. In RStudio, there’s a wonderful tool: if you type part of a variable or function name and press tab, RStudio will autocomplete it for you.

• Tip 6: no single parentheses. Whenever you open a parenthesis, you must close it. To make this task easier, go to Tools < Global Options < Code < Display and enable the Rainbow parentheses option.

• Tip 7: pay attention to the left side. You will not only see the line of code you are on but also, in case of a syntax error, RStudio will notify you.

• Tip 8: try to always work by projects (for this class, create a script class1.R in the project we created before)

 

See more tips at https://r4ds.had.co.nz/workflow-basics.html#whats-in-a-name

2.1 Data types (cells)

Are there variables beyond numbers in data science? For example, think about the data you might store about a person:

• Age or weight will be a number.

age <- 33

• Their name will be a string of text (known as string or char).

name <- "javi"

• The answer to the question “Are you enrolled in the Faculty?” will be what we call a logical variable (TRUE if enrolled or FALSE otherwise).

enrolled <- TRUE

• Their date of birth will be precisely that, a date.

2.1.1 Numerical variables

The simplest data (which we’ve already used) will be numeric variables. To find out the data class in R of a variable, we use the class() function.

a <- 5
class(a)

[1] "numeric"

a <- 5
b <- 2
a + b

[1] 7

To know its typology (format) variable we have typeof().

typeof(1) # 1 value but stored as a real number (double precision)

[1] "double"

typeof(as.integer(1)) # 1 value but stored as a floor number

[1] "integer"

Note that…

In R we have a collection of functions starting with as.x() that serve as conversion functions: a data that was of one type, we convert it to type x.

In addition to the “common” numbers we will have the plus/minus infinity coded as Inf or -Inf.

1/0

[1] Inf

-1/0

[1] -Inf

And values that are not real numbers not a number (indeterminacies, complexes numbers, etc) encoded as NaN.

0/0

[1] NaN

sqrt(-2)

Warning in sqrt(-2): NaNs produced

[1] NaN

With numeric variables we can perform the arithmetic operations of a calculator: adding (+)…

a + b

[1] 7

…square root (sqrt())…

sqrt(a)

[1] 2.236068

… power (^2, ^3)…

a^2

[1] 25

…absolute value (abs()), etc.

abs(a)

[1] 5

2.1.2 String variables

Let us imagine that, in addition to the age of a person we want to store his/her name: now the variable will be of type character.

name <- "Javi"
class(name)

[1] "character"

The text strings are a type with which we obviously cannot perform arithmetic operations (other operations such as pasting or locating patterns can be performed).

name + 1 # error when we try to sum 1 to a text

Error in name + 1: non-numeric argument to binary operator

Reminder

Text variables (character or string) are ** ALWAYS in quotes**: TRUE (logical, binary value) is not the same as "TRUE" (text).

2.1.2.1 First function: paste

As we have commented R we will call function a piece of encapsulated code under a name, and which depends on some input arguments. Our first function will be paste(): given two strings, it allows us to paste them together.

paste("Javi", "Álvarez")

[1] "Javi Álvarez"

Note that default pastes strings with a space, but we can add an optional argument to tell it the separator (in sep = ...).

paste("Javi", "Álvarez", sep = "*")

[1] "Javi*Álvarez"

How do I know what arguments does a function need?

By typing ? paste in the console, you will get a help in the multipurpose panel, where you can see in its header what arguments the function already has default arguments assigned to it.

 

The arguments (and their detail) can also be consulted by tabulating (after a comma).

paste0("Javi", "Álvarez")

[1] "JaviÁlvarez"

It is very important to understand the concept of default argument of a function in R: it is a value that the function uses but sometimes we may not see because already has a value assigned.

# Same
paste("Javi", "Álvarez")

[1] "Javi Álvarez"

paste("Javi", "Álvarez", sep = " ")

[1] "Javi Álvarez"

Note

The = operator is reserved for assigning arguments within functions. For all other assignments, we will use <-.

2.1.2.2 First package: glue

A more intuitive way to work with text is to use the {glue} package: the first thing to do is to “buy the book” (if we have never done it before). After that load the package

install.packages("glue") # just the first time
library(glue)

With the glue() function of that package we can use variables inside strings. For example, “age is … years old”, where the age is stored in a variable.

age <- 34
glue("I am {age} old")

I am 34 old

Within the keys we can also execute operations

units <- "days"
glue("I am {age * 365} {units} old")

I am 12410 days old

2.1.3 Logical variables

Another fundamental type will be the logical or binary variables (two values):

• TRUE: true stored internally as a 1.

• FALSE: false stored internally as a 0.

single <- FALSE # Single? --> NO
class(single)

[1] "logical"

Since they are stored internally as binary variables, we can perform arithmetic operations on them

2 * TRUE

[1] 2

FALSE - 1

[1] -1

As we will see shortly, logical variables can actually take a third value: NA or missing data, representing not available, and it will be very common to find it within a database.

missing <- NA
missing + 1

[1] NA

Important

Logical variables NOT text variables: "TRUE" is a text, TRUE is a logical value.

TRUE + 1

[1] 2

"TRUE" + 1

Error in "TRUE" + 1: non-numeric argument to binary operator

2.1.3.1 Logical conditions

Logical values are usually the result of evaluate logical conditions. For example, imagine that we want to check whether a person is named Javi.

name <- "María"

With the logical operator == we ask if what we have stored on the left is same as what we have on the right: we ASK

name == "Javi"

[1] FALSE

With its opposite != we ask if different.

name != "Javi"

[1] TRUE

Note that…

It is not the same <- (assignment) as == (we are asking, it is a logical comparison).

In addition to “equal to” versus “different” comparisons, also order comparisons such as less than <, greater than >, <= or >=. Is the person less than 32 years old?

age <- 34
age < 32 # less than 32 years old?

[1] FALSE

Age is greater than or equal to 38 years?

age >= 38

[1] FALSE

Is the saved name equal to Javi?

name <- "Javi"
name == "Javi"

[1] TRUE

2.1.4 Date variables

A very special data type: the date type data.

date_char <- "2021-04-21"

It looks like a simple text string but should represent an instant in time. What should happen if we add a 1 to a date?

date_char + 1

Error in date_char + 1: non-numeric argument to binary operator

Dates cannot be string/text: we must convert the text string to date.

 

To work with dates we will use the {lubridate} package, which we must install before we can use it.

install.packages("lubridate")

Once installed, of all the packages (books) that we have, we will indicate it to load this one concretely.

library(lubridate) 

Attaching package: 'lubridate'

The following objects are masked from 'package:base':

    date, intersect, setdiff, union

To convert to date type we will use the as_date() function of the {lubridate} package (default in yyyy-mm-dd format).

 

# it's not a date, it's a text!
date_char + 1

Error in date_char + 1: non-numeric argument to binary operator

class(date_char)

[1] "character"

date <- as_date("2023-03-28")
date + 1

[1] "2023-03-29"

class(date)

[1] "Date"

In as_date() the default date format is yyyy-mm-dd so if the string is not entered correctly…

as_date("28-08-2024")

Warning: All formats failed to parse. No formats found.

[1] NA

For any other format we must specify it in the optional argument format = ... such that %d represents days, %m months, %Y in 4-year format and %y in 2-year format.

as_date("28-03-2023", format = "%d-%m-%Y")

[1] "2023-03-28"

as_date("28-03-23", format = "%d-%m-%y")

[1] "2023-03-28"

as_date("03-28-2023", format = "%m-%d-%Y")

[1] "2023-03-28"

as_date("28/03/2023", format = "%d/%m/%Y")

[1] "2023-03-28"

In this package we have very useful functions for date management:

• With today() we can directly obtain the current date.

today()

[1] "2024-09-07"

• With now() we can obtain current date and time

now()

[1] "2024-09-07 11:37:27 CEST"

• With year(), month() or day() we can extract year, month and day

date_today <- today()
year(date_today)

[1] 2024

month(date_today)

[1] 9

2.1.5 Cheatsheets

More information

You have a pdf summary of the most important packages in the corresponding folder on campus

2.2 💻 It’s your turn

Try to perform the following exercises without looking at the solutions

Exercise 1

📝 Define a variable that stores your age (called age) and another with your name (called name).

Code

age <- 34
name <- "Javi"

Exercise 2

📝 Check with this variable age if it is NOT 60 years old or if it is called "Ornitorrinco" (you must obtain logical variables as a result).

Code

age != 60 # different to
name == "Ornitorrinco" # equal to

Exercise 3

📝 Why does the lower code give an error?

age + name

Error in age + name: non-numeric argument to binary operator

Exercise 4

📝 Define another variable called siblings that answers the question “do you have siblings?” and another variable that stores your date of birth (called birth_date).

Code

siblings <- TRUE

library(lubridate) # if not before
birth_date <- as_date("1989-09-10")

Exercise 5

📝 Define another variable with your last name (called surname) and use glue() to have, in a single variable called full_name, your first and last name separated by a comma.

Code

surname <- "Álvarez Liébana"
full_name <- glue("{name}, {surname}")
full_name

Exercise 6

📝 From birth_date extract the month.

Code

month(birth_date)

Exercise 7

📝 Calculate the days that have passed since your birth date until today (with the birth date defined in Exercise 4).

Code

today() - birth_date

Exercise 8

📝 Define the vector x as the concatenation of the first 5 odd numbers. Calculate the length of the vector

Code

# Two ways
x <- c(1, 3, 5, 7, 9)
x <- seq(1, 9, by = 2)

length(x)

Exercise 9

📝 Accesses the third element of x. Accesses the last element (regardless of length, a code that can always be executed). Removes the first element.

Code

x[3]
x[length(x)]
x[-1]

Exercise 10

📝 Get the elements of x greater than 4. Calculate the vector 1/x and store it in a variable.

Code

x[x > 4]
z <- 1/x
z

Exercise 11

📝 Create a vector representing the names of 5 people, one of whom is unknown.

Code

names <- c("Javi", "Sandra", NA, "Laura", "Carlos")
names

Exercise 12

📝 Find from the vector x of previous exercises the elements greater (strictly) than 1 AND also less (strictly) than 7. Find a way to find out if all the elements are positive or not.

Code

x[x > 1 & x < 7]
all(x > 0)

Exercise 13

📝 Given the vector x <- c(1, -5, 8, NA, 10, -3, 9), why does its mean return not a number but what is shown in the code below?

x <- c(1, -5, 8, NA, 10, -3, 9)
mean(x)

[1] NA

Exercise 14

📝 Given the vector x <- c(1, -5, 8, NA, 10, -3, 9), extract the elements occupying the locations 1, 2, 5, 6.

Code

x <- c(1, -5, 8, NA, 10, -3, 9)
x[c(1, 2, 5, 6)]
x[-2]

Exercise 15

📝 Given the vector x from the previous exercise, which ones have missing data? Hint: the is.something() functions check if the element is of type something (press tab).

Code

is.na(x)

Exercise 16

📝 Define the vector x as the concatenation of the first 4 even numbers. Calculate the number of elements of x strictly less than 5.

Code

x[x < 5] 
sum(x < 5)

Exercise 17

📝 Calculate the vector 1/x and get the ordered version (from smallest to largest) in the two possible ways

Code

z <- 1/x
sort(z)
z[order(z)]

Ejercicio 18

📝 Find of the vector x the elements greater (strictly) than 1 and less (strictly) than 6. Find a way to find out if all the elements are negative or not.

Code

x[x > 1 & x < 7]
all(x > 0)

2.3 Vectors: concatenation

When working with data, we often have columns that represent variables: we will refer to these as vectors, which are a concatenation of cells (values) of the same type (similar to a column in a table).

The simplest way to create a vector is with the c() function (c stands for concatenate), and you just need to input the elements within parentheses, separated by commas.

ages <- c(32, 27, 60, 61)
ages

[1] 32 27 60 61

Tip

An individual number x <- 1 (or x <- c(1)) is actually a vector of length one –> everything we know how to do with a number, we can do with a vector of numbers.

As you can see now in the environment, we have a collection of elements stored.

ages # ages = edades in spanish

[1] 32 27 60 61

The length of a vector can be calculated with length().

length(ages)

[1] 4

We can also concatenate vectors together (it repeats them one after another).

c(ages, ages, 8)

[1] 32 27 60 61 32 27 60 61  8

2.3.1 Numeric sequences

The most common type of vector is numeric, specifically, the well-known numeric sequences (e.g., the days of the month), used among other things, to index loops.

The seq(start, end) function allows us to create a [**numeric sequence]**{.hl-yellow} from a starting element to an ending one, advancing one by one.

seq(1, 31)

 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
[26] 26 27 28 29 30 31

Note that if we try this with characters, it won’t work since there is no predefined order among text strings.

"a":"z"

Warning: NAs introduced by coercion
Warning: NAs introduced by coercion

Error in "a":"z": NA/NaN argument

A shortcut is the 1:n command, which returns the same as seq(1, n).

1:7

[1] 1 2 3 4 5 6 7

If the starting element is greater than the ending one, it understands that the sequence is in descending order.

7:-3

 [1]  7  6  5  4  3  2  1  0 -1 -2 -3

We can also define a different step between consecutive elements with the by = ... argument.

seq(1, 7, by = 0.5) # seq from 1 to 7, with a step of 0.5

 [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5 6.0 6.5 7.0

Sometimes we may want to define a sequence with a specific length.

seq(1, 50, l = 7) # seq from 1 to 50 with length equal to 7

[1]  1.000000  9.166667 17.333333 25.500000 33.666667 41.833333 50.000000

We might also want to generate a vector of n repeated elements.

rep(0, 7) # vector of 7 0's

[1] 0 0 0 0 0 0 0

Since they are internally stored as numbers, we can also do this with dates.

seq(as_date("2023-09-01"), as_date("2023-09-10"), by = 1)

 [1] "2023-09-01" "2023-09-02" "2023-09-03" "2023-09-04" "2023-09-05"
 [6] "2023-09-06" "2023-09-07" "2023-09-08" "2023-09-09" "2023-09-10"

2.3.2 String vectors

A vector is a concatenation of elements of the same type, but they don’t necessarily have to be numbers. Let’s create a sample sentence.

sentence <- "My name is Javi"
sentence

[1] "My name is Javi"

length(sentence)

[1] 1

In the previous case, it wasn’t a vector, it was a single text element. To create a vector, we need to use c() again and separate elements with commas.

sentence <- c("My", "name", "is", "Javi")
sentence

[1] "My"   "name" "is"   "Javi"

length(sentence)

[1] 4

What will happen if we concatenate elements of different types?

c(1, 2, "javi", "3", TRUE)

[1] "1"    "2"    "javi" "3"    "TRUE"

Note that since all elements must be of the same type, what R does is convert everything to text, violating the data integrity.

c(3, 4, TRUE, FALSE)

[1] 3 4 1 0

It’s important to understand that logical values are actually internally stored as 0/1.

2.3.3 Operations with vectors

With numeric vectors, we can perform the same arithmetic operations as with numbers → a number is a vector (of length one).

What will happen if we add or subtract a value to a vector?

x <- c(1, 3, 5, 7)
x + 1

[1] 2 4 6 8

x * 2

[1]  2  6 10 14

Warning

Unless otherwise specified, in R, vector operations are always element by element.

2.3.3.1 Adding

Vectors can also interact with each other, so we can define, for example, vector sums (element by element).

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

[1]  3  7 11

Since the operation (e.g., a sum) is performed element by element, what will happen if we add two vectors of different lengths?

z <- c(1, 3, 5, 7)
x + z

Warning in x + z: longer object length is not a multiple of shorter object
length

[1]  3  7 11  9

What it does is recycle elements: if we have a vector of 4 elements and we add another with 3 elements, it will recycle the elements from the shorter vector.

2.3.3.2 Comparing

A very common operation is to ask questions of the data using logical conditions. For example, if we define a vector of temperatures…

Which days were below 22 degrees?

x <- c(15, 20, 31, 27, 15, 29)

x < 22

[1]  TRUE  TRUE FALSE FALSE  TRUE FALSE

This will return a logical vector, depending on whether each element meets the given condition (of the same length as the vector being queried). If we had a missing value (due to a sensor error that day), the evaluated condition would also be NA.

y <- c(15, 20, NA, 31, 27, 7, 29, 10)
y < 22

[1]  TRUE  TRUE    NA FALSE FALSE  TRUE FALSE  TRUE

Logical conditions can be combined in two ways:

• Intersection: all concatenated conditions must be met (AND conjunction with &) to return TRUE.

x < 30 & x > 15

[1] FALSE  TRUE FALSE  TRUE FALSE  TRUE

• Union: it is enough for at least one condition to be met (OR conjunction with |).

x < 30 | x > 15

[1] TRUE TRUE TRUE TRUE TRUE TRUE

With any() and all(), we can check if all elements satisfy the condition.

any(x < 30)

[1] TRUE

all(x < 30)

[1] FALSE

2.3.3.3 Getting elements

Another common operation is accessing or getting elements. The simplest way is to use the [i] operator (access the i-th element).

ages <- c(20, 30, 33, NA, 61) 
ages[3] # get the age's third person

[1] 33

Since a number is just a vector of length one, this operation can also be applied using a vector of indices to select.

y <- c("hi", "how", "are", "you", "?")
y[c(1:2, 4)] # first, second and fourth element

[1] "hi"  "how" "you"

Tip

To access the last element without worrying about its position, you can pass the vector’s length as the index x[length(x)].

2.3.3.4 Removing elements

Sometimes, instead of selecting, we may want to remove elements. This is done with the same operation but using negative indexing: the opetator [-i] «un-select» the i-th element

y

[1] "hi"  "how" "are" "you" "?"  

y[-2] # everything except the second element

[1] "hi"  "are" "you" "?"  

In many cases, we want to select or remove elements based on logical conditions, depending on the values, so we will pass the condition itself as the index (remember, x < 2 returns a logical vector).

ages <- c(15, 21, 30, 17, 45)
names <- c("javi", "maría", "sandra", "carla", "luis")
names[ages < 18] # names of people under 18

[1] "javi"  "carla"

2.3.3.5 Stats operations

We can also make use of statistical operations, such as sum(), which, given a vector, returns the sum of all its elements.

x <- c(1, -2, 3, -1)
sum(x)

[1] 1

What happens when a data point is missing?

x <- c(1, -2, 3, NA, -1)
sum(x)

[1] NA

By default, if we have a missing data point, the operation will also result in a missing value. To ignore that missing data, we use the optional argument na.rm = TRUE.

sum(x, na.rm = TRUE)

[1] 1

As we’ve mentioned, logical values are internally stored as 0 and 1, so we can use them in arithmetic operations.

For example, if we want to find out the number of elements that meet a condition (e.g., less than 3), those that do will be assigned a 1 (TRUE), and those that don’t will get a 0 (FALSE). Therefore, summing the logical vector will give us the number of elements that meet the condition.

x <- c(2, 4, 6)
sum(x < 3)

[1] 1

tats operations

Another common operation that can be useful is the cumulative sum with cumsum(), which, given a vector, returns a vector where each element is the sum of the first, the first plus the second, the first plus the second plus the third, and so on.

x <- c(1, 5, 2, -1, 8)
cumsum(x)

[1]  1  6  8  7 15

What happens when a data point is missing?

x <- c(1, -2, 3, NA, -1)
cumsum(x)

[1]  1 -1  2 NA NA

In the case of the cumulative sum, what happens is that from that point onward, all subsequent accumulated values will be missing.

Another common operation that can be useful is the difference (with delay) with diff() which, given a vector, returns a vector with the second minus the first, the third minus the second, the fourth minus the third…and so on.

x <- c(1, 8, 5, 3, 9, 0, -1, 5)
diff(x)

[1]  7 -3 -2  6 -9 -1  6

Using the argument lag = we can indicate the delay of this difference (e.g. lag = 3 implies that the fourth minus the first, the fifth minus the second, etc.).

x <- c(1, 8, 5, 3, 9, 0, -1, 5)
diff(x, lag = 3)

[1]  2  1 -5 -4 -4

Other common operations are mean, median, percentiles, etc.

• mean: centrality measure that consists of adding all the elements and dividing by the number of elements added. The best known but the least robust: given a set, if outliers (very large or very small values) are introduced, the mean is very easily perturbed.

x <- c(165, 170, 181, 191, 150, 155, 167, NA, 173, 177)
mean(x, na.rm = TRUE)

[1] 169.8889

• Median: measure of centrality that consists of ordering the elements and keeping the one that occupies the middle.

x <- c(165, 170, 181, 191, 150, 155, 167, 173, 177)
median(x)

[1] 170

• Quantiles: position measurements (they divide the data into equal parts).

quantile(x) # by default quantiles/percentiles 0-25-50-75-100

  0%  25%  50%  75% 100% 
 150  165  170  177  191 

quantile(x, probs = c(0.1, 0.4, 0.9))

  10%   40%   90% 
154.0 167.6 183.0 

2.3.3.6 Sorting

Finally, a common action is to know sort values:

• sort(): returns the sorted vector. By default from smallest to largest but with decreasing = TRUE we can change it.

ages <- c(81, 7, 25, 41, 65, 20, 33, 23, 77)
sort(ages)

[1]  7 20 23 25 33 41 65 77 81

sort(ages, decreasing = TRUE)

[1] 81 77 65 41 33 25 23 20  7

• order(): returns the index vector that we would have to use to have the vector ordered

order(ages)

[1] 2 6 8 3 7 4 5 9 1

ages[order(ages)]

[1]  7 20 23 25 33 41 65 77 81

2.4 💻 It’s your turn

Try to perform the following exercises without looking at the solutions

Exercise 1

📝 Define the vector x as the concatenation of the first 5 odd numbers. Calculate the length of the vector

Code

# Two ways
x <- c(1, 3, 5, 7, 9)
x <- seq(1, 9, by = 2)

length(x)

Exercise 2

📝 Access the third element of x. Access the last element (regardless of length, a code that can always be executed). Delete the first element.

Code

x[3]
x[length(x)]
x[-1]

Exercise 3

📝 Get the elements of x greater than 4. Calculate the vector 1/x and store it in a variable.

Code

x[x > 4]
z <- 1/x
z

Exercise 4

📝 Create a vector representing the names of 5 people, one of whom is unknown.

Code

names <- c("Javi", "Sandra", NA, "Laura", "Carlos")
names

Exercise 5

📝 Find from the vector x of exercises above the elements greater (strictly) than 1 and less (strictly) than 7. Find a way to find out if all the elements are positive or not.

Code

x[x > 1 & x < 7]
all(x > 0)

Exercise 6

📝 Given the vector x <- c(1, -5, 8, NA, 10, -3, 9), why does its mean return not a number but what is shown in the code below?

x <- c(1, -5, 8, NA, 10, -3, 9)
mean(x)

[1] NA

Exercise 7

📝 Given the vector x <- c(1, -5, 8, NA, 10, -3, 9), extract the elements occupying the locations 1, 2, 5, 6.

Code

x <- c(1, -5, 8, NA, 10, -3, 9)
x[c(1, 2, 5, 6)]
x[-2]

Exercise 8

📝 Given the x vector of the previous exercise, which ones have a missing data? Hint: the is.something() functions check if the element is of type something (press tab).

Code

is.na(x)

Exercise 9

📝 Define the vector x as the concatenation of the first 4 even numbers. Calculate the number of elements of x strictly less than 5.

Code

x[x < 5] 
sum(x < 5)

Exercise 10

📝 Calculate the vector 1/x and obtain the ordered version (from smallest to largest) in the two possible ways

Code

z <- 1/x
sort(z)
z[order(z)]

Exercise 11

📝 Calculate min and max of previous x vector

Code

min(x)
max(x)

Exercise 12

📝 Find of the vector x the elements greater (strictly) than 1 and less (strictly) than 6. Find a way to find out if all the elements are negative or not.

Code

x[x > 1 & x < 7]
all(x > 0)

3 🐣 Case study I: airquality

In the {datasets} package (already installed by default) we have several datasets and one of them is airquality. Below I have extracted 3 variables from that dataset (note that it is done with data$variable, that dollar will be important).

The data captures daily measurements (n = 153 observations) of air quality in New York, from May to September 1973. Six 6 variables were measured: ozone levels, solar radiation, wind, temperature, month and day.

library(datasets)
temperature <- airquality$Temp
month <- airquality$Month
day <- airquality$Day

3.1 Question 1

How to find out what represents the data? Think of a command that gives us information about objects in R, knowing that the dataset name is airquality.

Code

? airquality

# By using `? ...` we can look up in the help panel what the object means.

3.2 Question 2

Access only the first 5 temperature records. Then access the first, second, fifth and tenth.

Code

# 1 to 5
temperature[1:5] 

# other way
temperature[c(1, 2, 3, 4, 5)]

# first, second, fifth and tenth element
temperature[c(1, 2, 5, 10)]

3.3 Question 3

Access only the May temperature records (you have the temperatures stored, think about how to access them but now using a condition instead of specific indexes). Then access the May, April and June elements.

Code

temperature[month == 5]

# april, may and june
temperature[month == 4 | month == 5 | month == 6]

# another more readable form: %in% checks if
# the values are within an allowed list
temperature[month %in% c(4, 5, 6)]

3.4 Question 4

How many records do we have from May? And from April?

Code

# A form for May registrations
sum(month == 5)

# Another way: the length of a vector
length(temperature[month == 5])

# idem in April
sum(month == 4)

3.5 Question 5

Construct a new variable date with the date of each record (combining year, month and day), knowing that all the data are from 1973. Hint: to construct a date before you must have a vector of texts (for example, “1973-01-01”).

Code

# date variable
library(lubridate)
dates <- as_date(glue("{1973}-{month}-{day}"))

3.6 Question 6

Create a new variable temp_celsius with the temperature in ºC (knowing that it is calculated as \(celsius = (fahr - 32) * (5/9)\)). Then calculate how many days in June exceeded 30 degrees ºC.

Code

# Temp in celsius
temp_celsius <- (temperature - 32) * (5/9)
temp_celsius 

sum(temp_celsius[month == 6] > 30)

# other way
length(temp_celsius[month == 6 & temp_celsius > 30])

3.7 Question 7

What was the average temperature for the month of August?

Code

# average in August
mean(temperature[month == 8], na.rm = TRUE)
mean(temp_celsius[month == 8], na.rm = TRUE)

3.8 Question 8

Given the August temperature vector, order the temperatures (coldest first, warmest second).

Code

# sort
temp_sort <- sort(temp_celsius[month == 8])
temp_sort

# order
temp_ord <- temp_celsius[month == 8][order(temp_celsius[month == 8])]
temp_ord

4 First databases

When analyzing data we usually have several variables for each individual: we need a “table” to collect them.

4.1 First attempt: matrices

The most immediate option is matrices: concatenation of variables of same type and equal length.

 

Imagine we have heights and weights of 4 people. How to create a dataset with the two variables? The most common option is to use cbind(): concatenate (bind) vectors in the form of columns (c)

h <- c(150, 160, 170, 180)
w <- c(63, 70, 85, 95)
data_mat <- cbind(h, w)
data_mat 

       h  w
[1,] 150 63
[2,] 160 70
[3,] 170 85
[4,] 180 95

We can also build the matrix by rows with the rbind() function (concatenate - bind - by rows - r), although it is recommended to have each variable in column and individual in row as we will see later.

rbind(h, w) # Matrix by rows

  [,1] [,2] [,3] [,4]
h  150  160  170  180
w   63   70   85   95

• We can “view” the matrix with View(matrix).

• We can check dimensions with dim(), nrow() and ncol(): matrices are a type of tabular data (organized in rows and columns).

dim(data_mat)

[1] 4 2

nrow(data_mat)

[1] 4

ncol(data_mat)

[1] 2

We can also “flip” (transposed matrix) with t().

t(data_mat)

  [,1] [,2] [,3] [,4]
h  150  160  170  180
w   63   70   85   95

Since we now have two dimensions in our data, to access elements with [] we must provide two comma-separated indexes: row and column indexes

data_mat[2, 1] # second row, first column

  h 
160 

data_mat[1, 2] # first row, second column

 w 
63 

In some cases we will want to get the total data for an individual (a particular row but all columns) or the values of a whole variable for all individuals (a particular column but all rows). To do so, we leave one of the indexes unfilled.

data_mat[2, ] # second individual

  h   w 
160  70 

data_mat[, 1] # first variable

[1] 150 160 170 180

Much of what we have learned with vectors we can do with matrices, so we can for example access multiple rows and/or columns using the sequences of integers 1:n

data_mat[c(1, 3), 1] # first variable for first and third individual

[1] 150 170

We can also define a matrix from a numeric vector, rearranging the values in the form of a matrix (knowing that the elements are placed by columns).

z <- matrix(1:9, ncol = 3) 
z

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

We can even define an array of constant values, e.g. of zeros (to be filled later)

matrix(0, nrow = 2, ncol = 3)

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0

4.1.1 Matrix operations

With matrices it is the same as with vectors: when we apply an arithmetic operation we do it element by element

z/5

     [,1] [,2] [,3]
[1,]  0.2  0.8  1.4
[2,]  0.4  1.0  1.6
[3,]  0.6  1.2  1.8

To perform operations in a matrix sense we must add %%%, for example, to multiply matrices it will be %*%.

z * t(z)

     [,1] [,2] [,3]
[1,]    1    8   21
[2,]    8   25   48
[3,]   21   48   81

z %*% t(z)

     [,1] [,2] [,3]
[1,]   66   78   90
[2,]   78   93  108
[3,]   90  108  126

We can also perform operations by columns/rows without loops with the apply() function, and we will indicate as arguments

• the matrix
• the sense of the operation (MARGIN = 1 for rows, MARGIN = 2 for columns)
• the function to apply
• extra arguments needed by the function

For example, to apply an average to each variable, it will be mean applied with MARGIN = 2 (same function for each column).

# Mean for each column (MARGIN = 2)
apply(data_mat, MARGIN = 2, FUN = "mean")

     h      w 
165.00  78.25 

4.2 💻 It’s your turn

Try to perform the following exercises without looking at the solutions

Exercise 1

📝 Modify the code below to define an x matrix of ones, with 3 rows and 7 columns.

x <- matrix(0, nrow = 2, ncol = 3)
x

Code

x <- matrix(1, nrow = 3, ncol = 7)
x

Exercise 2

📝 To the above matrix, add 1 to each number in the matrix and divide the result by 5. Then calculate its transpose

Code

new_matrix <- (x + 1)/5
t(new_matrix)

Exercise 3

📝 Why does the code below return such a warning message?

matrix(1:15, nrow = 4)

Warning in matrix(1:15, nrow = 4): data length [15] is not a sub-multiple or
multiple of the number of rows [4]

     [,1] [,2] [,3] [,4]
[1,]    1    5    9   13
[2,]    2    6   10   14
[3,]    3    7   11   15
[4,]    4    8   12    1

Exercise 4

📝 Define the matrix x <- matrix(1:12, nrow = 4). Then get the data of the first individual, the data of the third variable, and the element (4, 1).

Code

x <- matrix(1:12, nrow = 4)
x[1, ] # first row
x[, 3] # third column
x[4, 1] # (4, 1) element

Exercise 5

📝 Define a matrix of 2 variables and 3 individuals such that each variable captures the height and age of 3 persons, so that the age of the second person is unknown (absent). Then calculate the mean of each variable (we should get a number!).

Code

data <- cbind("age" = c(20, NA, 25), "h" = c(160, 165, 170))
apply(data, MARGIN = 2, FUN = "mean", na.rm = TRUE) # mean by columns

Exercise 6

📝 Why does the lower code return an error? What is wrong?

mat <- cbind("age" = c(15, 20, 25), "names" = c("javi", "sandra", "carlos"))
mat

     age  names   
[1,] "15" "javi"  
[2,] "20" "sandra"
[3,] "25" "carlos"

mat + 1

Error in mat + 1: non-numeric argument to binary operator

4.3 Second attempt: data.frame

Arrays have the same problem as vectors: if we put together data of different types, it data integrity is compromised as it converts them (see the code below: the ages and the TRUE/FALSE are converted to text).

ages <- c(14, 24, NA)
single <- c(TRUE, NA, FALSE)
names <- c("javi", "laura", "lucía")
mat <- cbind(ages, single, names)
mat

     ages single  names  
[1,] "14" "TRUE"  "javi" 
[2,] "24" NA      "laura"
[3,] NA   "FALSE" "lucía"

In fact, since they are not numbers, we can no longer perform arithmetic operations.

mat + 1

Error in mat + 1: non-numeric argument to binary operator

In order to work with variables of different type we have in R what is known as data.frame: concatenation of variables of equal length but which can be of different type.

table <- data.frame(ages, single, names)
class(table)

[1] "data.frame"

table

  ages single names
1   14   TRUE  javi
2   24     NA laura
3   NA  FALSE lucía

Since a data.frame is already an attempt at a database the variables are not mere mathematical vectors: they have a meaning and we can (we must) give them names that describe their meaning.

library(lubridate)
table <-
  data.frame("ages" = ages, "single" = single, "names" = names,
             "birth_date" = as_date(c("1989-09-10", "1992-04-01", "1980-11-27")))
table

  ages single names birth_date
1   14   TRUE  javi 1989-09-10
2   24     NA laura 1992-04-01
3   NA  FALSE lucía 1980-11-27

We have our first data set! (strictly speaking we can’t talk about a database but for the moment it looks like one). You can visualize it by typing its name in console or with View(table).

4.3.1 Get variables

If we want to access its elements, being again tabulated data, we can access as in the matrices (not recommended): again we have two indexes (rows and columns, leaving free the one we don’t use)

table[2, ]  # second row (all variables)

  ages single names birth_date
2   24     NA laura 1992-04-01

table[, 3]  # third column (all individuals)

[1] "javi"  "laura" "lucía"

table[2, 1] # first variable of the second individual

[1] 24

But it also has the advantages of a database : we can access the variables by name (recommended since the variables can change position and now they have a meaning), putting the name of the table followed by the symbol $ (with the tab, a menu of columns to choose from will appear).

4.3.2 Ask functions

• names(): shows us the variable names

names(table)

[1] "ages"       "single"     "names"      "birth_date"

• dim(): shows dimensions (also nrow() and ncol())

dim(table)

[1] 3 4

• Variables can be accessed by name

table[c(1, 3), "names"]

[1] "javi"  "lucía"

table$names[c(1, 3)]

[1] "javi"  "lucía"

4.3.3 Add a variable

If we have one already created and we want to add a column it is as simple as using the data.frame() function we have already seen to concatenate the column. Let’s add for example a new variable, the number of siblings of each individual.

# add a new column
siblings <- c(0, 2, 3)
table <- data.frame(table, "n_sib" = siblings)
table

  ages single names birth_date n_sib
1   14   TRUE  javi 1989-09-10     0
2   24     NA laura 1992-04-01     2
3   NA  FALSE lucía 1980-11-27     3

4.4 Last attempt: tibble

Tables in data.frame format have some limitations. The main one is that does not allow recursion: imagine that we define a database with heights and weights, and we want a third variable with the BMI.

data.frame("height" = c(1.7, 1.8, 1.6), "weight" = c(80, 75, 70),
           "BMI" = weight / (height^2))

Error in data.frame(height = c(1.7, 1.8, 1.6), weight = c(80, 75, 70), : object 'weight' not found

Hereafter we will use the tibble (enhanced data.frame) format from the {tibble} package.

library(tibble)
data_tb <- 
  tibble("height" = c(1.7, 1.8, 1.6), "weight" = c(80, 75, 70), "BMI" = weight / (height^2))
class(data_tb)

[1] "tbl_df"     "tbl"        "data.frame"

data_tb

# A tibble: 3 × 3
  height weight   BMI
   <dbl>  <dbl> <dbl>
1    1.7     80  27.7
2    1.8     75  23.1
3    1.6     70  27.3

Tables in tibble format will allow a more agile, efficient and coherent data management, with 4 main advantages:

• Metainformation: if you look at the header, it automatically tells us the number of rows and columns, and the type of each variable

• Recursivity: allows you to define the variables sequentially (as we have seen)

• Consistency: if you access a column that does not exist, it warns you with a warning

data_tb$invent

Warning: Unknown or uninitialised column: `invent`.

NULL

• By rows: create by rows (copy and paste from a table) with tribble().

tribble(~colA, ~colB,
        "a",   1,
        "b",   2)

# A tibble: 2 × 2
  colA   colB
  <chr> <dbl>
1 a         1
2 b         2

Tip

The {datapasta} package allows us to copy and paste tables from web pages and simple documents.

4.5 💻 It’s your turn

Try to perform the following exercises without looking at the solutions

Exercise 1

📝 Load from the {datasets} package the airquality dataset (New York air quality variables from May through September 1973). Is the airquality dataset of type tibble? If not, convert it to tibble (look in the package documentation at https://tibble.tidyverse.org/index.html).

Code

library(tibble)
class(datasets::airquality)
airquality_tb <- as_tibble(datasets::airquality)

Exercise 2

📝 Once converted to tibble get the name of the variables and the dimensions of the data set. How many variables are there? How many days have been measured?

Code

names(airquality_tb)
ncol(airquality_tb)
nrow(airquality_tb)

Exercise 3

📝 Filters only the data of the fifth observation

Code

airquality_tb[5, ]

Exercise 4

📝 Filter only the data for the month of August. How to tell it that we want only the rows that meet a specific condition?

Code

airquality_tb[airquality_tb$Month == 8, ]

Exercise 5

📝 Select those data that are not from July or August.

Code

airquality_tb[airquality_tb$Month != 7 & airquality_tb$Month != 8, ]
airquality_tb[!(airquality_tb$Month %in% c(7, 8)), ]

Exercise 6

📝 Modify the following code to keep only the ozone and temperature variables (no matter what position they are).

airquality_tb[, 3]

Exercise 7

📝 Select the temperature and wind data for August.

Code

airquality_tb[airquality_tb$Month == 8, c("Temp", "Wind")]

Exercise 8

📝 Translate the name of the variables into your native language.

Code

names(airquality_tb) <- c("ozono", "rad_solar", "viento", "temp", "mes", "dia") 

5 🐣 Case study II: survey data

We will consider the surveys.RData file in which we have all poll surveys for Spain from 1982 to 2019.

load(file = "./datos/surveys.RData")

5.1 Question 1

How many different polling firms we have?

Code

# 93 polling firms (including parties)
unique(survey_data$pollster)

5.2 Question 2

Filter just surveys with known sample size greater than 500

Code

survey_data <-
  survey_data[survey_data$size > 500 & !is.na(survey_data$size), ]

5.3 Question 3

Filter then just surveys for the 10-11-2019 elections with no absent estimation value

Code

survey_data <- survey_data[survey_data$date_elec == "2019-11-10" &
                             !is.na(survey_data$estimation), ]

5.4 Question 4

Include a new logical variable to know if a survey was done by CIS (Spanish sociological research center) or not.

Code

survey_data$CIS <- survey_data$pollster == "CIS"

5.5 Question 5

Which was the average estimation for PSOE provided by the CIS and the rest of surveys? And for PP?

Code

# average PSOE by CIS
mean(survey_data[survey_data$CIS &
                   survey_data$party == "PSOE", ]$estimation)
# average PSOE by others
mean(survey_data[!survey_data$CIS &
                   survey_data$party == "PSOE", ]$estimation)
# difference of 3 points in average

# average PP by CIS
mean(survey_data[survey_data$CIS &
                   survey_data$party == "PP", ]$estimation)
# average PP by others
mean(survey_data[!survey_data$CIS &
                   survey_data$party == "PP", ]$estimation)
# difference of -4 points in average

5.6 Question 6

Replicate the previous comparison but just considering surveys 90 days before the date of election and with more than 3 field days.

Code

survey_data$days_field <-
  survey_data$field_date_to - survey_data$field_date_from
survey_data$days_to_elec <-
  survey_data$date_elec - survey_data$field_date_from

survey_data_filtered <-
  survey_data[survey_data$days_to_elec < 90 &
                survey_data$days_field > 3, ]

# average PSOE by CIS
mean(survey_data_filtered[survey_data$CIS &
                            survey_data_filtered$party == "PSOE", ]$estimation)
# average PSOE by others
mean(survey_data_filtered[!survey_data_filtered$CIS &
                            survey_data_filtered$party == "PSOE", ]$estimation)
# difference of 3 points in average

# average PP by CIS
mean(survey_data_filtered[survey_data_filtered$CIS &
                            survey_data_filtered$party == "PP", ]$estimation)
# average PP by others
mean(survey_data_filtered[!survey_data_filtered$CIS &
                            survey_data_filtered$party == "PP", ]$estimation)
# difference of -2 points in average