Introduction to R

source_code: embed

1. What is R?

Technically R is an expression language with a very simple syntax. It is also perfect for exploration. It can be used in any kind of analysis work, as it has many tools and is also very extensible. Additionally, it is a perfect fit for big data solutions. You can do whatever you want with R such as if you have tons of picture/maps you can convert and combine to Pdf(s). You can also make presentation,send email, write report and even you can make your own website with R.In summary, it is a powerful, extensible environment. It has a wide range of statistics and general data analysis and visualization capabilities including-

• Data handling, wrangling, and storage
• Wide array of statistical methods and graphical techniques available
• Easy to install on any platform and use (and it’s free!)
• Open source with a large and growing community of peers
• R Studio: Graphical user interface, not just a command prompt

Obviously there are some other language that can do same types of work so why we should use R? * The answer is simple. It is easy to learn and it has a tons of ready to use package! But Organizational language is another obvious reason for using R.

Things should be considered before writing a R script

1. It is case sensitive as are most UNIX based packages, so A and a are different symbols and would refer to different variables. For example if you declear a variable with “name” and then very next line you try to recall the variable with “Name” the it wouldn’t work

name <- c("Rupal","Gemma","Carmine","Mehedi")

name

[1] "Rupal"   "Gemma"   "Carmine" "Mehedi" 

Name

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

2. Sometimes it is difficut to find out the problem in calculation For example in below we have a dataset which contains the monthly income of REACH staffs. We have to calculate annual income from the dataset

df %>% kable()

df$monthly_income %>% class()

[1] "character"

So very next you made the it number by as.numeric() function. However there is another error in annual income of Sakar. There is a “.” in monthly income tab which seems not be current. Ideally it shoud be stoped when coverting “.” to numeric value but R did not make the code stop instead it make the value as NA. Which sometimes make error is calculation specially when you have tons of data and it is nearly impossible with eye to find such type of problem.

df_With_annual_income <- df %>% mutate(
  monthly_income = as.numeric(monthly_income)
)

df_With_annual_income %>% kable()

However there are numerous ways to check this type of problem.We will talk about it later.

The swirl package is an R package that lets you build interactive tutorials for R, right inside R.

Basic of R

R and RStudio

RStudio is an integrated development environment (IDE) for R. It includes a console, syntax-highlighting editor that supports direct code execution, as well as tools for plotting, history, debugging and workspace management.

RStudio is available in open source and commercial editions and runs on the desktop (Windows, Mac, and Linux) or in a browser connected to RStudio Server or RStudio Server Pro (Debian/Ubuntu, Red Hat/CentOS, and SUSE Linux).

Install R & RStudio: Download both R and RStudio. Install R first and then RStudio.

2. R Studio interface

• Top left: Script editor (where you write your scripts)
• Bottom left: Console (the “engine”, i.e. where you run your scripts)
• Top right: Environment/history (where you see active objects in your session)
• Bottom right: Files/plots/packages/help

3. Basic terms

• Operator - symbol performing specific mathematical or logical manipulation
• Variable - column of data in a data frame
• Observation - row of data in a data frame
• Datapoint - single cell value
• Vector - sequence of data elements of the same basic type
• Matrix - same as a vector, but two-dimensional
• Dataframe (df) - R equivalent to an Excel/SPSS table dataset

4. Basic data structure (vectors)

A vector is the most common and basic data structure in R, the workhorse of R. It is a collection of values of the same basic type. The c() function returns a vector.

# define the vector
myVector <- c(1, 50, 9, 42)

# display the vector
myVector 

[1]  1 50  9 42

govs <- c("Anbar", "Baghdad", "Basra", "Duhok", "Kirkuk", "Ninevah")
govs 

[1] "Anbar"   "Baghdad" "Basra"   "Duhok"   "Kirkuk"  "Ninevah"

back to top

5. Operators

5.1 Assignment

• <-, <<-, = : Leftwards assignment
• ->, ->> : Rightwards assignment

element <- "this is a value"
element

[1] "this is a value"

5.2 Arithmetic

• + : Addition
  
• - : Subtraction
  
• * : Multiplication
  
• / : Division
  
• ^ : Exponent
  
• %% : Modulus (remainder from division)
  
• %/% : Integer division

Examples of arithmetic operators:

3 - 2

[1] 1

v <- c(2, 5, 6)
t <- c(8, 3, 4)
v + t

[1] 10  8 10

5^2 * 2

[1] 50

5.3 Relational

• < : Less than
• > : Greater than
• <= : Less than or equal to
• >= : Greater than or equal to
• == : Equal to
• != : Not equal to

Examples of relational operators:

1 == 2

[1] FALSE

4 > 3

[1] TRUE

"a" != "b"

[1] TRUE

v <- c(2, 5, 6, 9)
t <- c(8, 3, 4, 9)
v > t

[1] FALSE  TRUE  TRUE FALSE

5.4 Logical

• ! : Logical NOT
• & : Element-wise logical AND
• && : Logical AND
• | : Element-wise logical OR
• || : Logical OR

1 & 3 < 4

[1] TRUE

1 & 3 > 4

[1] FALSE

1 | 3 < 2

[1] TRUE

5.5 Other operators

• : operator - creates the series of numbers in sequence for a vector

v <- 2:8
v

[1] 2 3 4 5 6 7 8

• %in% - used to identify if an element belongs to a vector

v <- 5
t <- c(1:7)

v %in% t

[1] TRUE

9 %in% t

[1] FALSE

back to top

6. Data types

6.1 Character The character class is your typical string, a set of one or more letters.

myString <- "Hello R!"
myString

[1] "Hello R!"

You can check the class associated with the object we defined above, by wrapping it in the class() function.

class(myString)

[1] "character"

6.2 Numeric Indicates numeric values like 10, 15.6, -48792.54989827 and so on.

myNum <- 10.4343
myNum

[1] 10.4343

class(myNum)

[1] "numeric"

6.3 Integer Integers are whole numbers, though they get autocoerced (changed) into numerics when saved into variables.

myInt <- 209173987
class(myInt)

[1] "numeric"

myInt <- as.integer(myInt)
class(myInt)

[1] "integer"

myInt <- 209173987L
class(myInt)

[1] "integer"

6.4 Logical Logical types (booleans) are the same as in most other languages and can be two things – either true, or false. True can be represented with TRUE or T while false is FALSE or F.

Logical_1 <- TRUE 
class(Logical_1)

[1] "logical"

Logical_2 <- 2 < 1 
class(Logical_2)

[1] "logical"

6.5 Factors A factor is a type of vector that is used to store categorical data. Each unique category is referred to as a factor level (category = level).

Strlevels <- c("low", "high", "medium", "high", "low", "medium", "high")
Factorlevels <- factor(Strlevels)
Factorlevels

[1] low    high   medium high   low    medium high  
Levels: high low medium

class(Factorlevels)

[1] "factor"

6.6 Lists Lists are the R objects containing different data types: numbers, strings, vectors, another list, a matrix, a function. Lists are created using list().

list_data <- list(c("Red", "Green"), c(21,32,11), TRUE, 51.23)
list_data

[[1]]
[1] "Red"   "Green"

[[2]]
[1] 21 32 11

[[3]]
[1] TRUE

[[4]]
[1] 51.23

Matrices A matrix in R is a collection of vectors of same length and identical datatype. Vectors can be combined as columns in the matrix or by row, to create a 2-dimensional structure. Matrices are mostly used for mathematical calculations.

matrix  <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
matrix

     [,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6

6.8 Data frame

A data frame is the most common way of storing data in R and, generally, is the data structure most often used for data analyses. Under the hood, a data frame is a list of equal-length vectors. Each element of the list can be thought of as a column and the length of each element of the list is the number of rows. As a result, data frames can store different classes of objects in each column (i.e. numeric, character, factor). Typically, data frames have column headers (i.e. variable names).

In essence, the easiest way to think of a data frame is as an Excel worksheet that contains columns of different types of data but are all of equal length rows.

Example

Let’s define a data frame, using the data.frame() function, and then have a look at it:

df <- data.frame(col1 = 1:3, 
                 col2 = c("this", "is", "text"), 
                 variable_name3 = c(TRUE, FALSE, TRUE), 
                 Variable.4 = c(2.5, 4.2, pi))

df

  col1 col2 variable_name3 Variable.4
1    1 this           TRUE   2.500000
2    2   is          FALSE   4.200000
3    3 text           TRUE   3.141593

class(df$col1)

[1] "integer"

class(df$col2)

[1] "character"

class(df$variable_name3)

[1] "logical"

class(df$Variable.4)

[1] "numeric"

Importing data in R Typically, you do not create your own data frame in R, but load in a dataset, which you then use to do calculations on.

Generally, it is good practice to work with CSV files rather than Excel sheets. As needed, you define the character separating cells in your CSV file, and specify strings that should be treated as missing values (or NA):

data <- read.csv("data/example_data.csv")
data <- read.csv("data/example_data.csv", na.strings = c("NA", ""), sep = ",")

You can find more documentation on data input functions here.

Working with “projects” (.Rproj): RStudio projects make it straight-forward to divide your work into multiple contexts, each with their own working directory, workspace, history, and source documents.

Click on “File >> New Project” to create a new project file. Once a project file is created, open it (which opens a new R session) and open your scripts from within R (via the bottom right “Files” pane).

A major advantage of working with project files is that they automatically set the working directory to where the respective project documents are saved. When you load in datasets from your project folder, it means the document path will be relative and therefore much cleaner (as in the above example).

More info on projects is found here.

Inspecting your data

All data structures:

• str(): compact display of data contents (env.)
• class(): returns data type
• summary(): summarizes aspect of data depending on data class
• head(): prints the beginning entries for the variable in the console
• tail(): prints the end entries for the variable in the console

Vector and factor variables:

• length(): returns the number of elements in the vector or factor

Dataframe and matrix variables:

• dim(): returns dimensions of the data frame or matrix (ie. # of rows and columns)
• nrow(): returns the number of rows in the dataset
• ncol(): returns the number of columns in the dataset
• rownames(): returns the row names in the dataset
• colnames(): returns the column names in the dataset

back to top

Functions

A key feature of R is functions. Functions are “self contained” modules of code that accomplish a specific task. Functions usually take in some sort of data structure (value, vector, dataframe etc.), process it, and return a result.

The syntax of formulas always follows the same structure: The name of the function is followed by parentheses (), in which the input arguments are specified.

Examples:

• sum(1,2) Adds two or more numbers
• sum(a) sums a numeric vector
• sum(b, na.rm = TRUE) sums a numeric vector and removes all instances of empty values (NA)

Other examples of base R functions: seq(), mean(), max().

a <- c(7,3,12,19)
mean(a)

[1] 10.25

b <- c(7,3,12, NA)
mean(b, na.rm = TRUE)

[1] 7.333333

There are many, many more functions that are available. As we will see later, R also allows users to define their own functions.

back to top

8. Missing values (NA)

In R, missing values are represented by the symbol NA (not available). Missing values are not the same as empty values ("") - empty values ("") are blanks, while missing values (NA) are truly missing.

Test for missing values

Here is how you can test for missing data:

v <- c(7,3,12,NA)
is.na(v)

[1] FALSE FALSE FALSE  TRUE

Exclude empty values

v <- c(7,3,12,NA)
mean(v)

[1] NA

mean(v, na.rm = TRUE)

[1] 7.333333

Specifying NAs when importing datasets

When importing a dataset into R, make sure you specify the NA values in the na.strings as needed. Failing to do so may affect your analysis later on, as blanks ("") are regular values that will be evaluated and therefore might skew your results.

data <- read.csv("data/example_data.csv", na.strings = c("NA", ""))

back to top

R packages

R packages are collections of functions and datasets developed by the community. They increase the power of R by improving existing base R functionalities, or by adding new ones.

Imagine that you would like to analyze stratified household-level data, make maps of migration routes and charts for your reports, extract price data from the web, or build an online dashboard, R packages got you covered! Recently, the official repository (CRAN) reached 10,000 packages published by eager developers from all over the world, and many more are publicly available through the internet.

The directory where packages are stored is called the library. R comes with a standard set of packages. Others are available for download and installation. Once installed, they have to be loaded into the session to be used.

install.packages("dplyr")

library(dplyr)

Popular packages that you might want to check out if you start using R regularly are:

• dplyr: For data manipulation
• tidyr: For tidying your data and making it easier to work with
• survey and srvyr: For analyzing survey data
• ggplot2: For making graphs
• leaflet: For making maps
• sf: For geo-processing
• shiny: For building interactive apps and dashboards

back to top

Dplyr

source_code: embed ## Dplyr

Pretext The dplyr package is part of the very popular tidyverse collection, which includes a number of very useful packages (such as dplyr, tidyr and ggplot2). dplyr allows you to quickly add/drop columns, filter data, mutate existing data, as well as summarize data. Given its speed, and relatively simple syntax, it is preferred by many R developers as the workhorse for data wrangling. Some of the most popular functions from the package are filter(), group_by() and summarise().

This tutorial goes over the most important functions and illustrates them using an example dataset from the 2020 MSNA in Iraq.

Data wrangling: Data wrangling is the process of transforming and mapping data from one “raw” data form into another format with the intent of making it more appropriate and valuable for a variety of downstream purposes such as analytics.

1. Overview of data wrangling functions The package includes many different functions. The most common ones are the following:

• select(): Pick columns based on their names and/or types
• filter(): Pick rows based on conditions about their values
• mutate(): Create a new variable by mutating existing ones
• case_when(): To create statements with if/else logic
• group_by(): Group rows of observations together
• summarise(): Compute summary statistics of variables
• join(): Merge two dataframes together

Other useful functions are:

• rename(): Rename columns in your dataset
• arrange(): Order rows by values of a column
• distinct(): Remove rows with duplicate values
• bind_rows() / bind_cols(): Paste tables below/besides each other

Have a look at the dplyr cheat sheet for more functions.

2. The Pipe %>% The pipe operator (%>%) is unique to the dplyr package and allows you to chain together different functions. The pipe operator can be read as “then” - it allows us to go from one step to the next.

For example, we can:

• filter our data frame to only focus on a few rows (e.g. only keep refugee households) then
• group_by another variable to create groups (e.g. group by governorate) then
• summarise this grouped data to calculate the mean for each level of the group. (e.g. derive average income of refugee households by governorate)

3. Key functions

All the functions below will be illustrated on an example dataset, which looks like the following:

kable(data) %>% scroll_box(width = "1200px", height = "500px")