Data Manipulation with Tidy Tools

1 Prerequisites

Before you get started, make sure you have all tutorial materials downloaded and R and RStudio installed on your machine. If you don’t have these installed on your machine, the following are instructions for you to install this software.

1.1 Installing R

R is a powerful, open-source statistical programming language that anyone can download for free! You can simply go to CRAN’s website and install R by following these steps:

1.1.1 Under the ‘Download’ heading, select ‘CRAN’

1.1.2 Install a CRAN Mirror

Install the CRAN mirror that’s nearest to your geographic location. For example, if you live in Orange County, California, you should install the UCLA CRAN Mirror.

1.1.3 Install your Machine’s Version of R

1.1.3.1 R for Windows

Install R for the first time.

After you click this link, follow the instructions given in the installation.

1.1.3.2 R for (Mac) OS X

After you click this link, follow the instructions given in the installation.

1.1.3.3 R for Linux

Install the R version relevant to your Linux server, and follow the instructions given in the installation.

1.2 Installing RStudio

RStudio is an open-source professional software that makes R much easier to use. Download the free, open-source license version from RStudio’s website. The installation steps are very similar to those of R’s for all operating systems.

1.3 Updating R and RStudio

If the aforementioned packages and functions start to not work after an extended period of time, you may need to update your versions of R, R packages, and RStudio software to the latest versions.

1.3.1 Updating R

To update your version of R, first close any R or RStudio windows you have open.

1.3.1.1 Updating R on Windows

Open the R GUI (x64, not i386). This is not the same as RStudio. The R GUI program icon should look very similar to this:

Install the installr package into R by typing

install.packages("installr")

into the Console.

After the package is finished installing, call the package by typing

library(installr)

into the Console. You can now update your R software and packages to the latest versions by typing

updateR() 

into the Console. Then R will walk you through a detailed and intuitive process of updating your R software and packages to the latest versions.

1.3.1.2 Updating R on (Mac) OS X

Open RStudio again, and type the following lines of code into the Console:

install.packages('devtools') #assuming it isn't already installed
library(devtools)
install_github('andreacirilloac/updateR')
library(updateR)
updateR(admin_password = "os_admin_user_password")

R will then walk you through a detailed and intuitive process of updating your R software and packages to the latest versions.

1.3.1.3 Updating R on Linux

This resource will walk you through how to update your R software and packages to the latest versions on Linux.

1.3.2 Updating R Packages Without Updating R

Updating out-of-date packages that were installed from CRAN (with install.packages()) is easy with the update.packages() function. Type this function into the RStudio Console.

update.packages()

After entering this function, it will ask you what packages you want to update. To update all packages at once, use ask = FALSE.

update.packages(ask = FALSE)

To update packages installed from devtools::install_github(), type the following function into your RStudio Console (I would also recommend saving this function in an R Script for later use):

update_github_pkgs <- function() {
  # check/load necessary packages
  # devtools package
  if (!("package:devtools" %in% search())) {
    tryCatch(require(devtools), error = function(x) {warning(x); cat("Cannot load devtools package \n")})
    on.exit(detach("package:devtools", unload=TRUE))
  }

  pkgs <- installed.packages(fields = "RemoteType")
  github_pkgs <- pkgs[pkgs[, "RemoteType"] %in% "github", "Package"]

  print(github_pkgs)
  lapply(github_pkgs, function(pac) {
    message("Updating ", pac, " from GitHub...")

    repo = packageDescription(pac, fields = "GithubRepo")
    username = packageDescription(pac, fields = "GithubUsername")

    install_github(repo = paste0(username, "/", repo))
  })
}

Then call the function.

update_github_pkgs()

1.3.3 Updating RStudio

To update RStudio, open RStudio and go to Help > Check for Updates to install the newest version.

2 Data Types

R has a wide variety of data types including vectors (numerical, character, logical), matrices, lists, and data frames. Matrices are composed of vectors, and data frames are composed of lists.

2.1 Vectors

a <- c(1,2,5.3,6,-2,4) # numeric vector
b <- c("one","two","three") # character vector
c <- c(TRUE,TRUE,TRUE,FALSE,TRUE,FALSE) #logical vector

You can refer to elements of a vector using subscripts.

a[c(2,4)] # 2nd and 4th elements of vector

## [1] 2 6

2.2 Matrices

All columns in a matrix must have the same mode (numeric, character, etc.) and the same length. The general format is

mymatrix <- matrix(vector, nrow=r, ncol=c, byrow=FALSE,
   dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE indicates that the matrix should be filled by rows. byrow=FALSE indicates that the matrix should be filled by columns (the default). dimnames provides optional labels for the columns and rows.

# generates 5 x 4 numeric matrix
x <- matrix(1:20, nrow=5,ncol=4)

# another example
cells <- c(1,26,24,68)
rnames <- c("R1", "R2")
cnames <- c("C1", "C2")
mymatrix <- matrix(cells, nrow=2, ncol=2, byrow=TRUE,
  dimnames=list(rnames, cnames))

Like in vectors, you can identify rows, columns or elements using subscripts.

x[,4] # 4th column of matrix

## [1] 16 17 18 19 20

x[3,] # 3rd row of matrix

## [1]  3  8 13 18

x[2:4,1:3] # rows 2,3,4 of columns 1,2,3

##      [,1] [,2] [,3]
## [1,]    2    7   12
## [2,]    3    8   13
## [3,]    4    9   14

2.3 Lists

An ordered collection of objects (components). A list allows you to gather a variety of (possibly unrelated) objects under one name.

# example of a list with 4 components -
# a string, a numeric vector, a matrix, and a scalar
list1 <- list(name="Fred", mynumbers=a, mymatrix=x, age=5.3)
list2 <- list(character="Louise", show="Bob's Burgers", time=830)

# example of a list containing two lists
ultimate_list <- c(list1,list2)

Identify elements of a list using the [[]] convention.

ultimate_list[[2]] # 2nd component of the list

## [1]  1.0  2.0  5.3  6.0 -2.0  4.0

ultimate_list[["mynumbers"]] # component named mynumbers in list

## [1]  1.0  2.0  5.3  6.0 -2.0  4.0

2.4 Data Frames

A data frame is more general than a matrix, in that different columns can have different modes (numeric, character, factor, etc.). This is similar to SAS and SPSS datasets.

d <- c(1,2,3,4)
e <- c("red", "white", "red", NA)
f <- c(TRUE,TRUE,TRUE,FALSE)
mydata <- data.frame(d,e,f)
names(mydata) <- c("ID","Color","Passed") # variable names

There are a variety of ways to identify the elements of a data frame.

mydata[2:3] # columns 2,3 of data frame

mydata[c("ID","Passed")] # columns ID and Passed from data frame

mydata$Color # variable Color in the data frame

## [1] red   white red   <NA> 
## Levels: red white

2.5 Useful Functions for All Data Types

length(object) # number of elements or components
str(object)    # structure of an object
class(object)  # class or type of an object
names(object)  # names

c(object,object,...)       # combine objects into a vector
cbind(object, object, ...) # combine objects as columns
rbind(object, object, ...) # combine objects as rows

object     # prints the object

ls()       # list current objects
rm(object) # delete an object

newobject <- edit(object) # edit copy and save as newobject
fix(object)               # edit in place 

3 Importing and Working with Data

3.1 Reading in the Dataset

Today, we’re going to be using one of the over 40,000 open datasets available in NASA’s Open Data Repository. This “Meteorite Landings” dataset is from the Meteoritical Soceity and contains information on all of the known meteorite landings, going as far back as the early 1800’s.

This data can be downloaded at this link.

To read in our data (.csv) file, we can use the following command:

meteorite_landings <- read.csv("data/Meteorite_Landings.csv")

Note 1: The syntax above assumes the .csv file is saved to the working directory. To change the working directory, navigate to Session > Set Working Directory > Choose Working Directory or type setwd("C:/Users/path") into the Console.

Note 2: read.csv reads the file, but we can’t use the data unless we assign it to a variable. We can think of a variable as a container with a name, such as x, current_temperature, or subject_id that contains one or more values. We can create a new variable in R and assign a value to it using <-.

Once you run the above command, you should see a meteorite_landings object in the “Environment” box in the top right corner of RStudio.

Now, let’s explore the dataset.

3.2 Viewing the Dataset

If we want to view our entire dataset, we can type View(meteorite_landings) into the Console. However, for large data sets it is much faster and more convenient to use the function head to display only the first few rows of data.

head(meteorite_landings)

3.2.1 Structure

To view the structure of, or data types for, each variable in a dataset, use the str, or “structure” function.

str(meteorite_landings)

## 'data.frame':    45716 obs. of  10 variables:
##  $ name       : Factor w/ 45716 levels "Österplana 002",..: 68 69 73 77 473 484 496 497 502 521 ...
##  $ id         : num  1 2 6 10 370 379 390 392 398 417 ...
##  $ nametype   : Factor w/ 2 levels "Relict","Valid": 2 2 2 2 2 2 2 2 2 2 ...
##  $ recclass   : Factor w/ 466 levels "Acapulcoite",..: 333 197 85 1 339 85 360 190 339 242 ...
##  $ mass       : num  21 720 107000 1914 780 ...
##  $ fall       : Factor w/ 2 levels "Fell","Found": 1 1 1 1 1 1 1 1 1 1 ...
##  $ year       : Factor w/ 270 levels "","01/01/1583 12:00:00 AM",..: 124 197 198 223 148 165 195 59 176 166 ...
##  $ reclat     : num  50.8 56.2 54.2 16.9 -33.2 ...
##  $ reclong    : num  6.08 10.23 -113 -99.9 -64.95 ...
##  $ GeoLocation: Factor w/ 17101 levels "","(-1.002780, 37.150280)",..: 16779 16983 16923 9106 844 14808 16496 16453 784 721 ...

3.2.1.1 Data Types

Note that meteorite_landings is a data frame. You can think of this structure as a spreadsheet in MS Excel. Data frames are very useful for storing data, and you will use them frequently when programming in R. A typical data frame of experimental data contains individual observations in rows and variables in columns. Also note that there are 2 different data types in our dataset:

1. Factor - A Class (not a string or number!)

2. Num - Numeric, float/number than can include decimal places

3.2.2 Dimensions

We can see the shape, or dimensions, of the data frame with the function dim:

dim(meteorite_landings)

## [1] 45716    10

This tells us that our data frame, meteorite_landings, has 45,716 rows and 10 columns.

3.2.2.1 Indexing

If we want to get a single value from the data frame, we can provide an index in square brackets. The first number specifies the row and the second the column:

# first value in meteorite_landings, row 1, column 1
meteorite_landings[1, 1]

## [1] Aachen
## 45716 Levels: Österplana 002 Österplana 003 ... Zvonkov

# middle value in meteorite_landings, row 22858, column 5
meteorite_landings[22858, 5]

## [1] 4.7

3.2.2.2 Subsetting

If we want to select more than one row or column, we can use the function c, which stands for combine. For example, to pick columns 1 and 5 from rows 1, 3, and 5, we can do this:

meteorite_landings[c(1, 3, 5), c(1, 5)]

We frequently want to select contiguous rows or columns, such as the first ten rows, or columns 3 through 7. You can use c for this, but it’s more convenient to use the : operator. This special function generates sequences of numbers:

1:5

## [1] 1 2 3 4 5

3:12

##  [1]  3  4  5  6  7  8  9 10 11 12

For example, we can select the first 2 columns of values for the first four rows like this:

meteorite_landings[1:4, 1:2]

or the first 5 columns of rows 5 to 10 like this:

meteorite_landings[5:10, 1:5]

If you want to select all rows or all columns, leave that index value empty.

# All columns from row 5
meteorite_landings[5, ]

# All rows from columns 6-8
meteorite_landings[, 6:8]

If you leave both index values empty (i.e., meteorite_landings[,]), you get the entire data frame.

3.3 Mathematical Operations

Now let’s perform some common mathematical operations to learn more about our meteorite data. When analyzing data we often want to look at partial statistics, such as the maximum value per id or the average value per year. One way to do this is to select the data we want to create a new temporary data frame, and then perform the calculation on this subset:

# first 5 rows, columns 1,5
first_fifty_meteors <- meteorite_landings[1:50, 5]
# max mass of first 50 meteors
max(first_fifty_meteors, na.rm = T)

## [1] 2e+06

# also correct:
max(meteorite_landings[1:50, 5], na.rm = T)

## [1] 2e+06

R also has functions for other common calculations, e.g. finding the minimum, mean, median, and standard deviation of the data:

# minimum mass of first 50 meteors
min(first_fifty_meteors, na.rm = T)

## [1] 21

# mean mass of first 50 meteors
mean(first_fifty_meteors, na.rm = T)

## [1] 54289.93

# median mass of first 50 meteors
median(first_fifty_meteors, na.rm = T)

## [1] 2600

# standard deviation of the mass of the first 50 meteors
sd(first_fifty_meteors, na.rm = T)

## [1] 289093.5

R also has a function that summaries the previous common calculations. For every column in the data frame, the function summary calculates: the minimum value, the first quartile, the median, the mean, the third quartile, and the max value, giving helpful details about the sample distribution.

# Summarize function
summary(meteorite_landings)

##               name             id          nametype        recclass    
##  Österplana 002:    1   Min.   :    1   Relict:   75   L6     : 8285  
##  Österplana 003:    1   1st Qu.:12689   Valid :45641   H5     : 7142  
##  Österplana 004:    1   Median :24262                  L5     : 4796  
##  Österplana 005:    1   Mean   :26890                  H6     : 4528  
##  Österplana 006:    1   3rd Qu.:40657                  H4     : 4211  
##  Österplana 007:    1   Max.   :57458                  LL5    : 2766  
##  (Other)        :45710                                  (Other):13988  
##       mass             fall                  year           reclat      
##  Min.   :       0   Fell : 1107   1/1/2003 0:00: 3323   Min.   :-87.37  
##  1st Qu.:       7   Found:44609   1/1/1979 0:00: 3046   1st Qu.:-76.71  
##  Median :      33                 1/1/1998 0:00: 2697   Median :-71.50  
##  Mean   :   13278                 1/1/2006 0:00: 2456   Mean   :-39.12  
##  3rd Qu.:     203                 1/1/1988 0:00: 2296   3rd Qu.:  0.00  
##  Max.   :60000000                 1/1/2002 0:00: 2078   Max.   : 81.17  
##  NA's   :131                      (Other)      :29820   NA's   :7315    
##     reclong                          GeoLocation   
##  Min.   :-165.43                           : 7315  
##  1st Qu.:   0.00   (0.000000, 0.000000)    : 6214  
##  Median :  35.67   (-71.500000, 35.666670) : 4761  
##  Mean   :  61.07   (-84.000000, 168.000000): 3040  
##  3rd Qu.: 157.17   (-72.000000, 26.000000) : 1505  
##  Max.   : 354.47   (-79.683330, 159.750000):  657  
##  NA's   :7315      (Other)                 :22224

4 Manipulating and sorting dataframes with dplyr

4.1 What is dplyr?

dplyr is an R package in the tidyverse that aims to make data wrangling/cleaning/manipulation more human-readable. The dplyr package makes these steps fast and easy:

• By constraining your options, it helps you think about your data manipulation challenges.

• It provides simple “verbs”, functions that correspond to the most common data manipulation tasks, to help you translate your thoughts into code.

• It uses efficient backends, so you spend less time waiting for the computer.

This tutorial introduces you to dplyr’s basic set of tools, and shows you how to apply them to data frames. Aside from this tutorial, a helpful resource for getting familiar with dplyr is this comprehensive RStudio cheatsheet.

Side Note: dplyr also supports databases via the dbplyr package. Once you install dbplyr, you can read vignette("dbplyr") to learn more.

4.2 Getting Started with dplyr

If you don’t already have dplyr or the tidyverse installed, you can install the dplyr package by typing the following command into the Console:

install.packages("dplyr")

Once you have dplyr installed, load it into your R session with

library(dplyr)

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

dplyr aims to provide a function for each basic verb of data manipulation:

Function	Purpose
filter()	to select cases based on their values
arrange()	to reorder the cases
select(), rename()	to select variables based on their names
mutate(), transmute()	to add new variables that are functions of existing variables
summarise()	to condense multiple values to a single value
sample_n(), sample_frac()	to take random samples

In this tutorial, we’ll spend some time working with each individual function.

4.2.1 Piping Operator (%>%)

The operators %>% pipe their left-hand side values forward into expressions that appear on the right-hand side, i.e. one can replace f(x) with x %>% f(), where %>% is the (main) pipe-operator. When coupling several function calls with the pipe-operator, the benefit will become more apparent. Consider this pseudo example:

the_data <- read.csv('/path/to/data/file.csv') %>%
  subset(variable_a > x) %>%
  transform(variable_c = variable_a/variable_b) %>%
  head(100)

Four operations are performed to arrive at the desired data set, and they are written in a natural order: the same as the order of execution. Also, no temporary variables are needed. If yet another operation is required, it is straight-forward to add to the sequence of operations wherever it may be needed.

4.3 Filter rows with filter()

filter() allows you to select a subset of rows in a data frame. Like all single verbs, the first argument is the data frame. The second and subsequent arguments refer to variables within that data frame, selecting rows where the expression is TRUE.

For example, we can select all meteorites in the L5 class with mass greater than or equal to 10,000 grams with:

meteorite_landings %>% 
  filter(mass >= 10000 & recclass == "L5")

This is roughly equivalent to this base R code:

meteorite_landings[meteorite_landings$mass >= 10000 & meteorite_landings$recclass == "L5", ]

4.4 Arrange rows with arrange()

arrange() works similarly to filter() except that instead of filtering or selecting rows, it reorders them. It takes a data frame and a set of column names (or more complicated expressions) to order by. If you provide more than one column name, each additional column will be used to break ties in the values of preceding columns:

meteorite_landings %>% 
  arrange(reclat, reclong, mass)

Use desc() to order a column in descending order:

meteorite_landings %>% 
  arrange(desc(mass))

4.5 Select columns with select()

Often you work with large datasets with many columns but only a few are actually of interest to you. select() allows you to rapidly zoom in on a useful subset using operations that usually only work on numeric variable positions:

# Select columns by name
meteorite_landings %>% 
  select(name, recclass, mass)

# Select all columns between name and year (inclusive)
meteorite_landings %>% 
  select(name:year)

# Select all columns except those from name to year (inclusive)
meteorite_landings %>% 
  select(-(name:year))

There are a number of helper functions you can use within select(), like starts_with(), ends_with(), matches() and contains(). These let you quickly match larger blocks of variables that meet some criterion. See ?select for more details.

You can rename variables with select() by using named arguments:

meteorite_landings %>% 
  select(mass_g = mass)

But because select() drops all the variables not explicitly mentioned, it’s not that useful. Instead, use rename():

meteorite_landings %>% 
  rename(mass_g = mass)

4.6 Add new columns with mutate()

Besides selecting sets of existing columns, it’s often useful to add new columns that are functions of existing columns. This is the job of mutate():

meteorite_landings %>% 
  mutate(mass_kg = mass/1000)

dplyr::mutate() is similar to the base transform(), but allows you to refer to columns that you’ve just created.

If you only want to keep the new variables, use transmute():

meteorite_landings %>% 
  transmute(mass_kg = mass/1000)

4.7 Summarise values with summarise()

The last verb is summarise(). It collapses a data frame to a single row.

meteorite_landings %>% 
  summarise(mean_mass = mean(mass, na.rm = T))

It’s not that useful until we learn the group_by() verb below.

meteorite_landings %>% 
  group_by(recclass) %>% 
  summarise(mean_mass = mean(mass, na.rm = T))

4.8 Randomly sample rows with sample_n() and sample_frac()

You can use sample_n() and sample_frac() to take a random sample of rows: use sample_n() for a fixed number and sample_frac() for a fixed fraction.

meteorite_landings %>% 
  sample_n(10)

meteorite_landings %>% 
  sample_frac(0.01)

Use replace = TRUE to perform a bootstrap sample. If needed, you can weight the sample with the weight argument.

4.9 Ten dplyr Tricks!

4.9.1 Are you often selecting the same columns over and over again?

You can make a vector of pre-identified columns once and then refer to them using one_of() or !! (even shorter).

library(dplyr)

cols <- c("name", "reclat", "reclong")

ex1 <- meteorite_landings %>% 
  select(!!cols)

head(ex1)

4.9.2 Select columns via regex

If you have matching patterns, you can use starts_with(), contains(), or ends_with. But what if your pattern isn’t that exact? Simple: enter regex into matches().

library(dplyr)

ex2 <- iris %>% 
  select(matches("S.+th"))

head(ex2)

4.9.3 Reordering your columns

If you just want to bring one or more columns to the front, you can use everything() to add all the remaining columns.

library(dplyr)

ex3 <- meteorite_landings %>% 
  select(id, everything())

head(ex3)

4.9.4 Renaming all variables in one go

One command to get them all in lower case, and one more to replace “..g.” in the mass variable.

library(dplyr)
library(stringr)

ex4 <- meteorite_landings %>% 
  rename_all(tolower) %>% 
  rename_all(~str_replace(., "..g.", ""))

head(ex4)

4.9.5 Cleaning up your observations in one go

The select_all/if/at and rename_all/if/at functions will only modify the variable names, not the observations. If you want to change those, use the mutate variant.

library(dplyr)
library(stringr)

ex5 <- meteorite_landings %>% 
  select(name, nametype, fall) %>% 
  mutate_all(tolower) %>% 
  mutate_all(~str_replace_all(., " ", "_"))

head(ex5)

4.9.6 Finding the 5 highest/lowest values

You can use top_n to find the 5 meteorites with the highest mass without ordering them first.

library(dplyr)

meteorite_landings %>% 
  top_n(5, mass)

4.9.7 Adding the amount of observations

You can add the amount of observations without summarising them yourself. If you don’t like the default column name n, you can change it again with a rename() statement.

library(dplyr)

ex7 <- meteorite_landings %>% 
  add_count(recclass) %>% 
  rename(n_recclass = n)

head(ex7)

4.9.8 Making new discrete variables

case_when() can be a very powerful tool to make new discrete variables based on other columns.

library(dplyr)

ex8 <- starwars %>% 
  select(name, species, homeworld, birth_year, hair_color) %>% 
  mutate(new_group = case_when(
    species == "Droid" ~ "Robot",
    homeworld == "Tatooine" & hair_color == "blond" ~ "Blond Tatooinian",
    homeworld == "Tatooine" ~ "Other Tatooinian",
    hair_color == "blond" ~ "Blond non-Tatooinian",
    TRUE ~ "Other Human"))

head(ex8)

4.9.9 Going rowwise…

Mutating with aggregate functions by default will take the average/sum/… of the entire column. Via adding rowwise() you can aggregate within an observation.

library(dplyr)

ex9 <- iris %>% 
  select(contains("Length")) %>% 
  rowwise() %>% 
  mutate(avg_length = mean(c(Petal.Length, Sepal.Length)))

head(ex9)

4.9.10 Changing your column names after summarise_if

If you’ve used the summarise_all/if/at variants before, you know that the variable name by default does not get changed. If you want a modified name, you can wrap your function inside funs() and add a tag that will be added to the variable name.

library(dplyr)

iris %>% 
  summarise_if(is.numeric, funs(avg = mean))

5 Additional Resources

5.1 Helpful Packages To Get Started With

To learn more about and read documentation for each of these packages, either type ?<packagename> into your RStudio console or search <packagename> in the CRAN repository.

• blob - for storing blob (binary) data
• boot - bootstrap functions
• broom - tidies statistical models into data frames
• caret - streamlines the process for creating predictive models (Helpful Website)
• cluster - clustering methods
• coefplot - plots coefficients from fitted models
• data.table - extension of data.frames
• devtools - tools to make an R developer’s life easier
• dplyr - part of the Tidyverse, convenient data manipulation, munging, and cleaning in R
• forcats - part of the Tidyverse, solves common problems with factors
• gbm - gradient boosting models, can be integrated with caret
• ggplot2 - part of the Tidyverse, data visualization in R that follows the “Grammar of Graphics”
• glmnet - lasso and elastic-net regularized GLMs, can be integrated with caret
• gridExtra - miscellaneous functions for “grid” graphics
• hms - for working with time-of-day values
• ISLR - data for an “Introduction to Statistical Learning with Applications in R”
• lubridate - for working with dates and date-times
• MASS - functions and datasets for applied statistics
• pdp - partial dependence plots
• pls - partial least squares and principal component regression, can be integrated with caret
• plyr - part of the Tidyverse, tools for split-apply-combine analyses
• pROC - displays and analyzes ROC curves
• purrr - part of the Tidyverse, enhances R’s functional programming set of tools for working with functions and vectors
• randomForest - random forest models, can be integrated with caret
• readr - part of the Tidyverse, provides a fast and friendly way to read rectangular data
• readxl - part of the Tidyverse,makes reading Excel files much easier
• rpart - decision tree models, can be integrated with caret
• rpart.plot - plotting of decision tree models
• stringr - part of the Tidyverse, makes working with string objects much easier
• tibble - part of the Tidyverse, creates data.frames that are easier to work with
• tidyr - part of the Tidyverse, provides a set of functions to help you get to tidy data
• tidyverse - set of helpful packages for tidier data (Helpful Website)
• xgboost - eXtreme Gradient Boosting models, can be integrated with caret

5.2 R and RStudio Resources

5.2.1 RStudio Cheatsheets

RStudio Cheatsheets can be downloaded from the RStudio IDE by navigating to Help > Cheatsheets. The most commonly-used cheatsheets include:

• RStudio IDE Cheat Sheet
• Data Import Cheat Sheet
• Data Transformation with dplyr
• Data Visualization with ggplot2
• Dates and Times with lubridate
• String Manipulation with stringr
• Apply functions with purrr

5.2.2 Helpful Links

• CRAN Intro to R Manual
• The R Graph Gallery
• Top 50 ggplot2 visualizations

5.2.3 Google and Community

• Google and Try!
• RSeek.org (Google for R)
• OC R User Group
• R-Ladies Irvine
• #rstats community on Twitter

6 Thank you for attending my tutorial on “Data Manipulation with Tidy Tools.”

All tutorial materials can be found here on my GitHub.

Thanks so much for listening and following along, and I hope you’ll have a great rest of your hackathon!

---

A work by Alyssa Columbus.

hello@alyssacolumbus.com