Introduction

In this post, we will learn about the different methods of getting help in R. Often, we get stuck while doing some analysis as either we do not know the correct function to use or its syntax. It is important for anyone who is new to R to know the right place to look for help. There are two ways to look for help in R:

• built in help system
• online

In the first section, we will look at various online resources that can supplement the built in help system. In the second section, we will look at various ways to access the built in help system of R. Let us get started!

Online Resources

Internal

In this section, we will look at the following functions:

• help.start()
• help()
• ?
• ??
• help.search()
• demo()
• example()
• library()
• vignette()
• browseVignettes()

help.start()

## starting httpd help server ... done

## If nothing happens, you should open
## 'http://127.0.0.1:19951/doc/html/index.html' yourself

help(plot)
?plot

help.search('regression')
??regression

demo()
demo(scoping)

## 
## 
##  demo(scoping)
##  ---- ~~~~~~~
## 
## > ## Here is a little example which shows a fundamental difference between
## > ## R and S.  It is a little example from Abelson and Sussman which models
## > ## the way in which bank accounts work.    It shows how R functions can
## > ## encapsulate state information.
## > ##
## > ## When invoked, "open.account" defines and returns three functions
## > ## in a list.  Because the variable "total" exists in the environment
## > ## where these functions are defined they have access to its value.
## > ## This is even true when "open.account" has returned.  The only way
## > ## to access the value of "total" is through the accessor functions
## > ## withdraw, deposit and balance.  Separate accounts maintain their
## > ## own balances.
## > ##
## > ## This is a very nifty way of creating "closures" and a little thought
## > ## will show you that there are many ways of using this in statistics.
## > 
## > #  Copyright (C) 1997-8 The R Core Team
## > 
## > open.account <- function(total) {
## + 
## +     list(
## +     deposit = function(amount) {
## +         if(amount <= 0)
## +         stop("Deposits must be positive!\n")
## +         total <<- total + amount
## +         cat(amount,"deposited. Your balance is", total, "\n\n")
## +     },
## +     withdraw = function(amount) {
## +         if(amount > total)
## +         stop("You don't have that much money!\n")
## +         total <<- total - amount
## +         cat(amount,"withdrawn.  Your balance is", total, "\n\n")
## +     },
## +     balance = function() {
## +         cat("Your balance is", total, "\n\n")
## +     }
## +     )
## + }
## 
## > ross <- open.account(100)
## 
## > robert <- open.account(200)
## 
## > ross$withdraw(30)
## 30 withdrawn.  Your balance is 70 
## 
## 
## > ross$balance()
## Your balance is 70 
## 
## 
## > robert$balance()
## Your balance is 200 
## 
## 
## > ross$deposit(50)
## 50 deposited. Your balance is 120 
## 
## 
## > ross$balance()
## Your balance is 120 
## 
## 
## > try(ross$withdraw(500)) # no way..
## Error in ross$withdraw(500) : You don't have that much money!

example('mean')

## 
## mean> x <- c(0:10, 50)
## 
## mean> xm <- mean(x)
## 
## mean> c(xm, mean(x, trim = 0.10))
## [1] 8.75 5.50

Package Documentation

library(help = 'ggplot2')

vignette()

vignette('dplyr', package = 'dplyr')

## Warning: vignette 'dplyr' not found

browseVignettes()

RSiteSearch('glm')

## A search query has been submitted to http://search.r-project.org
## The results page should open in your browser shortly

Summary

To sum it up, the R community is very beginner friendly and we hope you will find all the above resources, both internal help system and online resources useful.

Introduction

R code contain a lot of parentheses in case of a sequence of multiple operations. When you are dealing with complex code, it results in nested function calls which are hard to read and maintain. The magrittr package by Stefan Milton Bache provides pipes enabling us to write R code that is readable.

Pipes allow us to clearly express a sequence of multiple operations by:

• structuring operations from left to right
• avoiding
  • nested function calls
  • intermediate steps
  • overwriting of original data
• minimizing creation of local variables

Pipes

If you are using tidyverse, magrittr will be automatically loaded. We will look at 3 different types of pipes:

• %>% : pipe a value forward into an expression or function call
• %<>%: result assigned to left hand side object instead of returning it
• %$% : expose names within left hand side objects to right hand side expressions

Libraries, Code & Data

We will use the following packages in this post:

• magrittr
• readr
• dplyr
• stringr
• and purrr

You can find the data sets here and the codes here.

library(magrittr)
library(readr)
library(dplyr)
library(stringr)
library(purrr)

Data

ecom <- 
  read_csv('https://raw.githubusercontent.com/rsquaredacademy/datasets/master/web.csv',
    col_types = cols_only(
      referrer = col_factor(levels = c("bing", "direct", "social", "yahoo", "google")),
      n_pages = col_double(), duration = col_double(), purchase = col_logical()
    )
  )

ecom

## # A tibble: 1,000 x 4
##    referrer n_pages duration purchase
##    <fct>      <dbl>    <dbl> <lgl>   
##  1 google         1      693 FALSE   
##  2 yahoo          1      459 FALSE   
##  3 direct         1      996 FALSE   
##  4 bing          18      468 TRUE    
##  5 yahoo          1      955 FALSE   
##  6 yahoo          5      135 FALSE   
##  7 yahoo          1       75 FALSE   
##  8 direct         1      908 FALSE   
##  9 bing          19      209 FALSE   
## 10 google         1      208 FALSE   
## # ... with 990 more rows

We will create a smaller data set from the above data to be used in some examples:

ecom_mini <- sample_n(ecom, size = 10)
ecom_mini

## # A tibble: 10 x 4
##    referrer n_pages duration purchase
##    <fct>      <dbl>    <dbl> <lgl>   
##  1 direct         1      136 FALSE   
##  2 direct         1      314 FALSE   
##  3 direct        18      324 TRUE    
##  4 social        10      290 TRUE    
##  5 yahoo          7      140 FALSE   
##  6 direct         1      658 FALSE   
##  7 bing          17      493 FALSE   
##  8 bing           1      406 FALSE   
##  9 social        15      405 FALSE   
## 10 google        15      210 FALSE

First Example

Let us start with a simple example. You must be aware of head(). If not, do not worry. It returns the first few observations/rows of data. We can specify the number of observations it should return as well. Let us use it to view the first 10 rows of our data set.

head(ecom, 10)

## # A tibble: 10 x 4
##    referrer n_pages duration purchase
##    <fct>      <dbl>    <dbl> <lgl>   
##  1 google         1      693 FALSE   
##  2 yahoo          1      459 FALSE   
##  3 direct         1      996 FALSE   
##  4 bing          18      468 TRUE    
##  5 yahoo          1      955 FALSE   
##  6 yahoo          5      135 FALSE   
##  7 yahoo          1       75 FALSE   
##  8 direct         1      908 FALSE   
##  9 bing          19      209 FALSE   
## 10 google         1      208 FALSE

ecom %>% head(10)

## # A tibble: 10 x 4
##    referrer n_pages duration purchase
##    <fct>      <dbl>    <dbl> <lgl>   
##  1 google         1      693 FALSE   
##  2 yahoo          1      459 FALSE   
##  3 direct         1      996 FALSE   
##  4 bing          18      468 TRUE    
##  5 yahoo          1      955 FALSE   
##  6 yahoo          5      135 FALSE   
##  7 yahoo          1       75 FALSE   
##  8 direct         1      908 FALSE   
##  9 bing          19      209 FALSE   
## 10 google         1      208 FALSE

Square Root

Time to try a slightly more challenging example. We want the square root of n_pages column from the data set.

y <- sqrt(ecom_mini$n_pages)

Let us break down the above computation into small steps:

• select/expose the n_pages column from ecom data
• compute the square root
• assign the first few observations to y

Let us reproduce y using pipes.

# select n_pages variable and assign it to y
y <-
    ecom_mini %$%
    n_pages

# compute square root of y and assign it to y 
y %<>% sqrt

Another way to compute the square root of y is shown below.

y <-
  ecom_mini %$% 
  n_pages %>% 
  sqrt()

Visualization

Let us look at a data visualization example. We will create a bar plot to visualize the frequency of different referrer types that drove purchasers to the website. Let us look at the steps involved in creating the bar plot:

• extract rows where purchase is TRUE
• select/expose referrer column
• tabulate referrer data using table()
• use the tabulated data to create bar plot using barplot()

barplot(table(subset(ecom, purchase)$referrer))

ecom %>%
  subset(purchase) %>%
  extract('referrer') %>%
  table() %>%
  barplot()

Correlation

Correlation is a statistical measure that indicates the extent to which two or more variables fluctuate together. In R, correlation is computed using cor(). Let us look at the correlation between the number of pages browsed and time spent on the site for visitors who purchased some product. Below are the steps for computing correlation:

• extract rows where purchase is TRUE
• select/expose n_pages and duration columns
• use cor() to compute the correlation

# without pipe
ecom1 <- subset(ecom, purchase)
cor(ecom1$n_pages, ecom1$duration)

## [1] 0.4290905

# with pipe
ecom %>%
  subset(purchase) %$% 
  cor(n_pages, duration)

## [1] 0.4290905

# with pipe
ecom %>%
  filter(purchase) %$% 
  cor(n_pages, duration)

## [1] 0.4290905

Regression

Let us look at a regression example. We regress time spent on the site on number of pages visited. Below are the steps involved in running the regression:

• use duration and n_pages columns from ecom data
• pass the above data to lm()
• pass the output from lm() to summary()

summary(lm(duration ~ n_pages, data = ecom))

## 
## Call:
## lm(formula = duration ~ n_pages, data = ecom)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -386.45 -213.03  -38.93  179.31  602.55 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  404.803     11.323  35.750  < 2e-16 ***
## n_pages       -8.355      1.296  -6.449 1.76e-10 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 263.3 on 998 degrees of freedom
## Multiple R-squared:   0.04,  Adjusted R-squared:  0.03904 
## F-statistic: 41.58 on 1 and 998 DF,  p-value: 1.756e-10

ecom %$%
  lm(duration ~ n_pages) %>%
  summary()

## 
## Call:
## lm(formula = duration ~ n_pages)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -386.45 -213.03  -38.93  179.31  602.55 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  404.803     11.323  35.750  < 2e-16 ***
## n_pages       -8.355      1.296  -6.449 1.76e-10 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 263.3 on 998 degrees of freedom
## Multiple R-squared:   0.04,  Adjusted R-squared:  0.03904 
## F-statistic: 41.58 on 1 and 998 DF,  p-value: 1.756e-10

String Manipulation

We want to extract the first name (jovial) from the below email id and convert it to upper case. Below are the steps to achieve this:

• split the email id using the pattern @ using str_split()
• extract the first element from the resulting list using extract2()
• extract the first element from the character vector using extract()
• extract the first six characters using str_sub()
• convert to upper case using str_to_upper()

email <- 'jovialcann@anymail.com'

# without pipe
str_to_upper(str_sub(str_split(email, '@')[[1]][1], start = 1, end = 6))

## [1] "JOVIAL"

# with pipe
email %>%
  str_split(pattern = '@') %>%
  extract2(1) %>%
  extract(1) %>%
  str_sub(start = 1, end = 6) %>%
  str_to_upper()

## [1] "JOVIAL"

Another method that uses map_chr() from the purrr package.

email %>%
  str_split(pattern = '@') %>%
  map_chr(1) %>%
  str_sub(start = 1, end = 6) %>%
  str_to_upper()

## [1] "JOVIAL"

Data Extraction

Let us turn our attention towards data extraction. magrittr provides alternatives to , we do not use quotes.

# base 
ecom_mini['n_pages']

## # A tibble: 10 x 1
##    n_pages
##      <dbl>
##  1       1
##  2       1
##  3      18
##  4      10
##  5       7
##  6       1
##  7      17
##  8       1
##  9      15
## 10      15

# magrittr
extract(ecom_mini, 'n_pages') 

## # A tibble: 10 x 1
##    n_pages
##      <dbl>
##  1       1
##  2       1
##  3      18
##  4      10
##  5       7
##  6       1
##  7      17
##  8       1
##  9      15
## 10      15

Extract Column By Position

We can extract columns using their index position. Keep in mind that index position starts from 1 in R. In the below example, we show how to extract n_pages column but instead of using the column name, we use the column position.

# base 
ecom_mini[2]

## # A tibble: 10 x 1
##    n_pages
##      <dbl>
##  1       1
##  2       1
##  3      18
##  4      10
##  5       7
##  6       1
##  7      17
##  8       1
##  9      15
## 10      15

# magrittr
extract(ecom_mini, 2) 

## # A tibble: 10 x 1
##    n_pages
##      <dbl>
##  1       1
##  2       1
##  3      18
##  4      10
##  5       7
##  6       1
##  7      17
##  8       1
##  9      15
## 10      15

Extract Column (as vector)

One important differentiator between [ and [[ is that [[ will return a atomic vector and not a data.frame. .

# base 
ecom_mini$n_pages

##  [1]  1  1 18 10  7  1 17  1 15 15

# magrittr
use_series(ecom_mini, 'n_pages') 

##  [1]  1  1 18 10  7  1 17  1 15 15

Extract List Element By Name

Let us convert ecom_mini into a list using as.list() as shown below:

ecom_list <- as.list(ecom_mini)

To extract elements of a list, we can use extract2(). It is an alternative for [[.

# base 
ecom_list[['n_pages']]

##  [1]  1  1 18 10  7  1 17  1 15 15

# magrittr
extract2(ecom_list, 'n_pages')

##  [1]  1  1 18 10  7  1 17  1 15 15

Extract List Element By Position

# base 
ecom_list[[1]]

##  [1] direct direct direct social yahoo  direct bing   bing   social google
## Levels: bing direct social yahoo google

# magrittr
extract2(ecom_list, 1)

##  [1] direct direct direct social yahoo  direct bing   bing   social google
## Levels: bing direct social yahoo google

Extract List Element

We can extract the elements of a list using use_series() as well.

# base 
ecom_list$n_pages

##  [1]  1  1 18 10  7  1 17  1 15 15

# magrittr
use_series(ecom_list, n_pages)

##  [1]  1  1 18 10  7  1 17  1 15 15

Introduction

A tibble, or tbl_df, is a modern reimagining of the data.frame, keeping what time has proven to be effective, and throwing out what is not. Tibbles are data.frames that are lazy and surly: they do less (i.e. they don’t change variable names or types, and don’t do partial matching) and complain more (e.g. when a variable does not exist). This forces you to confront problems earlier, typically leading to cleaner, more expressive code. Tibbles also have an enhanced print method() which makes them easier to use with large datasets containing complex objects.

Source: https://tibble.tidyverse.org/

In this post, we will explore tibbles. To be more precise, we will learn:

• how tibbles are different from data frames?
• how to create tibbles?
• how to manipulate tibbles?

Libraries, Code & Data

We will use the following packages:

• tibble
• dplyr

The code can be found here.

library(tibble)
library(dplyr)

Creating tibbles

tibble can be created using any of the following:

• tibble()
• as_tibble()
• tribble()

Let us start with tibble().

tibble(x = letters,
       y = 1:26,
       z = sample(100, 26))

## # A tibble: 26 x 3
##    x         y     z
##    <chr> <int> <int>
##  1 a         1    71
##  2 b         2    56
##  3 c         3    59
##  4 d         4    14
##  5 e         5    58
##  6 f         6    60
##  7 g         7    16
##  8 h         8     9
##  9 i         9    66
## 10 j        10    48
## # ... with 16 more rows

We mentioned the column names followed by the data. If you do not specify the column names, tibble() will supply them. Ensure that the length of each column is same.

tibble features

• never changes input’s types

tibble() will never alter the input’s type. For example, if you supply a character vector it will not be converted to factor unlike data.frame where you need to set stringsAsFactors to FALSE.

tibble(x = letters,
       y = 1:26,
       z = sample(100, 26))

## # A tibble: 26 x 3
##    x         y     z
##    <chr> <int> <int>
##  1 a         1    62
##  2 b         2    13
##  3 c         3    75
##  4 d         4    17
##  5 e         5    82
##  6 f         6    83
##  7 g         7     9
##  8 h         8    76
##  9 i         9    19
## 10 j        10    97
## # ... with 16 more rows

• never adjusts variable names

tibble() will never modify the column names. In the below example, you can observe that while data.frame adds a ., tibble() retains the column names as is.

names(data.frame(`order value` = 10))

## [1] "order.value"

names(tibble(`order value` = 10))

## [1] "order value"

• never prints all rows

tibble() will never print all the rows and clutter your console. It will only print the first 10 rows and only as many columns that fit the width of the console.

x <- 1:100
y <- letters[1]
z <- sample(c(TRUE, FALSE), 100, replace = TRUE)
tibble(x, y, z)

## # A tibble: 100 x 3
##        x y     z    
##    <int> <chr> <lgl>
##  1     1 a     TRUE 
##  2     2 a     FALSE
##  3     3 a     TRUE 
##  4     4 a     TRUE 
##  5     5 a     FALSE
##  6     6 a     TRUE 
##  7     7 a     TRUE 
##  8     8 a     FALSE
##  9     9 a     TRUE 
## 10    10 a     FALSE
## # ... with 90 more rows

• never recycles vector of length greater than 1

Recycling vectors of length greater than 1 often leads to errors and as such tibble() will only recycle vectors of length 1.

x <- 1:100
y <- letters
z <- sample(c(TRUE, FALSE), 100, replace = TRUE)
tibble(x, y, z)
Error in overscope_eval_next(overscope, expr) : object 'y' not found

Membership Testing

We can test if an object is a tibble using is_tibble().

is_tibble(mtcars)

## [1] FALSE

is_tibble(as_tibble(mtcars))

## [1] TRUE

Tribble

Another way to create tibbles is using tribble():

• it is short for transposed tibbles
• it is customized for data entry in code
• column names start with ~
• and values are separated by commas

tribble(
  ~x, ~y, ~z,
  #--|--|----
  1, TRUE, 'a',
  2, FALSE, 'b'
)

## # A tibble: 2 x 3
##       x y     z    
##   <dbl> <lgl> <chr>
## 1     1 TRUE  a    
## 2     2 FALSE b

Column Names

Names of the columns in tibbles need not be valid R variable names. They can contain unusual characters like a space or a smiley but must be enclosed in ticks.

tibble(
  ` ` = 'space',
  `2` = 'integer',
  `:)` = 'smiley'
)

## # A tibble: 1 x 3
##   ` `   `2`     `:)`  
##   <chr> <chr>   <chr> 
## 1 space integer smiley

Add Rows

Let us add data related to Safari browser to the web traffic data using add_row().

browsers <- enframe(c(chrome = 40, firefox = 20, edge = 30))
browsers

## # A tibble: 3 x 2
##   name    value
##   <chr>   <dbl>
## 1 chrome     40
## 2 firefox    20
## 3 edge       30

add_row(browsers, name = 'safari', value = 10)

## # A tibble: 4 x 2
##   name    value
##   <chr>   <dbl>
## 1 chrome     40
## 2 firefox    20
## 3 edge       30
## 4 safari     10

If we want to add the data at a particular row, we can specify the row number using the .before argument. Let us add the data related to Safari browser in the second row instead of the last row.

add_row(browsers, name = 'safari', value = 10, .before = 2)

## # A tibble: 4 x 2
##   name    value
##   <chr>   <dbl>
## 1 chrome     40
## 2 safari     10
## 3 firefox    20
## 4 edge       30

Add Columns

add_column() adds a new column to tibbles.

browsers <- enframe(c(chrome = 40, firefox = 20, edge = 30, safari = 10))
add_column(browsers, visits = c(4000, 2000, 3000, 1000))

## # A tibble: 4 x 3
##   name    value visits
##   <chr>   <dbl>  <dbl>
## 1 chrome     40   4000
## 2 firefox    20   2000
## 3 edge       30   3000
## 4 safari     10   1000

Rownames

The tibble package provides a set of functions to deal with rownames. Remember, tibble does not have rownames unlike data.frame. To check whether a data set has rownames, use has_rownames().

has_rownames(mtcars)

## [1] TRUE

remove_rownames(mtcars)

##     mpg cyl  disp  hp drat    wt  qsec vs am gear carb
## 1  21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
## 2  21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
## 3  22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
## 4  21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
## 5  18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
## 6  18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
## 7  14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
## 8  24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
## 9  22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
## 10 19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
## 11 17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
## 12 16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
## 13 17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
## 14 15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
## 15 10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
## 16 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
## 17 14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
## 18 32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
## 19 30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
## 20 33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1
## 21 21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
## 22 15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
## 23 15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
## 24 13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
## 25 19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
## 26 27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1
## 27 26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2
## 28 30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2
## 29 15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
## 30 19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6
## 31 15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8
## 32 21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2

head(rownames_to_column(mtcars))

##             rowname  mpg cyl disp  hp drat    wt  qsec vs am gear carb
## 1         Mazda RX4 21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## 2     Mazda RX4 Wag 21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## 3        Datsun 710 22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## 4    Hornet 4 Drive 21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## 5 Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## 6           Valiant 18.1   6  225 105 2.76 3.460 20.22  1  0    3    1

mtcars_tbl <- rownames_to_column(mtcars)
column_to_rownames(mtcars_tbl)

##                      mpg cyl  disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4           21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag       21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710          22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive      21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout   18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
## Valiant             18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
## Duster 360          14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
## Merc 240D           24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
## Merc 230            22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
## Merc 280            19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
## Merc 280C           17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
## Merc 450SE          16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
## Merc 450SL          17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
## Merc 450SLC         15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
## Cadillac Fleetwood  10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4
## Lincoln Continental 10.4   8 460.0 215 3.00 5.424 17.82  0  0    3    4
## Chrysler Imperial   14.7   8 440.0 230 3.23 5.345 17.42  0  0    3    4
## Fiat 128            32.4   4  78.7  66 4.08 2.200 19.47  1  1    4    1
## Honda Civic         30.4   4  75.7  52 4.93 1.615 18.52  1  1    4    2
## Toyota Corolla      33.9   4  71.1  65 4.22 1.835 19.90  1  1    4    1
## Toyota Corona       21.5   4 120.1  97 3.70 2.465 20.01  1  0    3    1
## Dodge Challenger    15.5   8 318.0 150 2.76 3.520 16.87  0  0    3    2
## AMC Javelin         15.2   8 304.0 150 3.15 3.435 17.30  0  0    3    2
## Camaro Z28          13.3   8 350.0 245 3.73 3.840 15.41  0  0    3    4
## Pontiac Firebird    19.2   8 400.0 175 3.08 3.845 17.05  0  0    3    2
## Fiat X1-9           27.3   4  79.0  66 4.08 1.935 18.90  1  1    4    1
## Porsche 914-2       26.0   4 120.3  91 4.43 2.140 16.70  0  1    5    2
## Lotus Europa        30.4   4  95.1 113 3.77 1.513 16.90  1  1    5    2
## Ford Pantera L      15.8   8 351.0 264 4.22 3.170 14.50  0  1    5    4
## Ferrari Dino        19.7   6 145.0 175 3.62 2.770 15.50  0  1    5    6
## Maserati Bora       15.0   8 301.0 335 3.54 3.570 14.60  0  1    5    8
## Volvo 142E          21.4   4 121.0 109 4.11 2.780 18.60  1  1    4    2

Glimpse

Use glimpse() to get an overview of the data.

glimpse(mtcars)

## Rows: 32
## Columns: 11
## $ mpg  <dbl> 21.0, 21.0, 22.8, 21.4, 18.7, 18.1, 14.3, 24.4, 22.8, 19.2, 17...
## $ cyl  <dbl> 6, 6, 4, 6, 8, 6, 8, 4, 4, 6, 6, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4,...
## $ disp <dbl> 160.0, 160.0, 108.0, 258.0, 360.0, 225.0, 360.0, 146.7, 140.8,...
## $ hp   <dbl> 110, 110, 93, 110, 175, 105, 245, 62, 95, 123, 123, 180, 180, ...
## $ drat <dbl> 3.90, 3.90, 3.85, 3.08, 3.15, 2.76, 3.21, 3.69, 3.92, 3.92, 3....
## $ wt   <dbl> 2.620, 2.875, 2.320, 3.215, 3.440, 3.460, 3.570, 3.190, 3.150,...
## $ qsec <dbl> 16.46, 17.02, 18.61, 19.44, 17.02, 20.22, 15.84, 20.00, 22.90,...
## $ vs   <dbl> 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,...
## $ am   <dbl> 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0,...
## $ gear <dbl> 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 4, 4, 4, 3,...
## $ carb <dbl> 4, 4, 1, 1, 2, 1, 4, 2, 2, 4, 4, 3, 3, 3, 4, 4, 4, 1, 2, 1, 1,...

Check Column

has_name() can be used to check if a tibble has a specific column.

has_name(mtcars, 'cyl')

## [1] TRUE

has_name(mtcars, 'gears')

## [1] FALSE

Summary

References

• https://tibble.tidyverse.org/
• http://r4ds.had.co.nz/tibbles.html

Introduction

In the previous post, we learnt about lists. In this post, we will learn about dataframe.

• create dataframe
• select columns
• select rows
• utitlity functions

Create dataframes

Use data.frame to create dataframes. Below is the function syntax:

args(data.frame)

## function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, 
##     fix.empty.names = TRUE, stringsAsFactors = default.stringsAsFactors()) 
## NULL

Data frames are basically lists with elements of equal lenght and as such, they are heterogeneous. Let us create a dataframe:

name <- c('John', 'Jack', 'Jill')
age <- c(29, 25, 27)
graduate <- c(TRUE, TRUE, FALSE)
students <- data.frame(name, age, graduate)
students

##   name age graduate
## 1 John  29     TRUE
## 2 Jack  25     TRUE
## 3 Jill  27    FALSE

Basic Information

class(students)
## [1] "data.frame"
names(students)
## [1] "name"     "age"      "graduate"
colnames(students)
## [1] "name"     "age"      "graduate"
str(students)
## 'data.frame':    3 obs. of  3 variables:
##  $ name    : chr  "John" "Jack" "Jill"
##  $ age     : num  29 25 27
##  $ graduate: logi  TRUE TRUE FALSE
dim(students)
## [1] 3 3
nrow(students)
## [1] 3
ncol(students)
## [1] 3

Select Columns

• []
• [[]]
• $

# using [
students[1]
##   name
## 1 John
## 2 Jack
## 3 Jill

# using [[
students[[1]]
## [1] "John" "Jack" "Jill"

# using $
students$name
## [1] "John" "Jack" "Jill"

students[, 1:3]
##   name age graduate
## 1 John  29     TRUE
## 2 Jack  25     TRUE
## 3 Jill  27    FALSE

students[, c(1, 3)]
##   name graduate
## 1 John     TRUE
## 2 Jack     TRUE
## 3 Jill    FALSE

Select Rows

# single row
students[1, ]
##   name age graduate
## 1 John  29     TRUE

# multiple row
students[c(1, 3), ]
##   name age graduate
## 1 John  29     TRUE
## 3 Jill  27    FALSE

If you have observed carefully, the column names has been coerced to type factor. This happens because of a default argument in data.frame which is stringsAsFactors which is set to TRUE. If you do not want to treat it as factors, set the argument to FALSE.

students <- data.frame(name, age, graduate, stringsAsFactors = FALSE)

We will learn about wrangling dataframes in a different post.

Introduction

In the previous post, we learnt about dataframes. In this post, we will learn about factors.

• create factors
• order levels
• specify labels
• check levels
• number of levels

Categorical or qualitative data in R is treated as data type factor.

Create Factors

args(factor)

## function (x = character(), levels, labels = levels, exclude = NA, 
##     ordered = is.ordered(x), nmax = NA) 
## NULL

devices <- factor(c('Mobile', 'Tablet', 'Desktop'))
devices

## [1] Mobile  Tablet  Desktop
## Levels: Desktop Mobile Tablet

# number of levels
nlevels(devices)

## [1] 3

# levels
levels(devices)

## [1] "Desktop" "Mobile"  "Tablet"

We will learn more about factors in a later post.

Introduction

In the previous post, we learnt about matrices. In this post, we will learn about lists. Lists are very useful as they are heterogeneous i.e. they can contain different data types. If you remember, vectors and matrices are homogeneous i.e. they can contain only one type of data. If you include different data types, they will all be coerced to the same type. With lists, it is different. We learnt how to create lists briefly in the previous post while naming the rows and columns of a matrix. In this post, we will delve deeper into lists.

• how to create lists
• access list elements
• name list elements
• coerce other R objects to list
• coerce list to other R objects

Creating Lists

To create a list, we use the list() function. Let us create a simple list to demonstrate how they can contain different data types.

# numeric vector
vect1 <- 1:10

# character vector 
vect2 <- c('Jack', 'John', 'Jill')

# logical vector
vect3 <- c(TRUE, FALSE)

# matrix
mat <- matrix(data = 1:9, nrow = 3)

# list
l <- list(vect1, vect2, vect3, mat)
l

## [[1]]
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## [[2]]
## [1] "Jack" "John" "Jill"
## 
## [[3]]
## [1]  TRUE FALSE
## 
## [[4]]
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9

If you observe the output, all the elements of the list retain their data types. Now let us learn how to access the elements of the list.

Access List Elements

You can access the elements of a list using the following operators:

• [[
• [
• operator can be used only when we have named elements in the list. Let us add names to the elements. Use the names() function to add names to the list.

  # named elements
  names(l) <- c('vect1', 'vect2', 'vect3', 'mat')
  l

  ## $vect1
  ##  [1]  1  2  3  4  5  6  7  8  9 10
  ## 
  ## $vect2
  ## [1] "Jack" "John" "Jill"
  ## 
  ## $vect3
  ## [1]  TRUE FALSE
  ## 
  ## $mat
  ##      [,1] [,2] [,3]
  ## [1,]    1    4    7
  ## [2,]    2    5    8
  ## [3,]    3    6    9

  # use $
  l$vect1

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

  # use [[
  l[['vect1']]

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

  # use [
  l['vect1']

  ## $vect1
  ##  [1]  1  2  3  4  5  6  7  8  9 10

Introduction

In the previous post, we learnt to create matrices. In this post, we will learn to:

• combining matrices
• index/subset matrices
• dissolve matrices

Append Data

In this section, we will learn how to append data to a matrix. There are two functions that can be used for this purpose:

• rbind()
• cbind()

cbind will append a new column to the matrix while rbind will append a new row.

# 3 x 3 matrix
mat <- matrix(data = 1:9, nrow = 3)
mat

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

# numeric vector
v <- c(10, 11, 12)
v

## [1] 10 11 12

# append row
rbind(mat, v)

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

# append column
cbind(mat, v)

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

Combine Matrices

When you use rbind to combine two matrices, the number of columns must match and in case of cbind, the number of rows must match.

# 3 x 3 matrix
mat1 <- matrix(data = 1:9, nrow = 3)
mat2 <- matrix(data = sample(9), nrow = 3)

# append rows
rbind(mat1, mat2)

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

# append columns
cbind(mat1, mat2)

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

Subset Matrices

In this section, we will learn to subset matrices. The [] operator can be used to subset matrices just like vectors but since matrices are two dimensional, we need to specify both the row number and the column number. Below are a few examples:

# 3 x 4 matrix
mat <- matrix(data = 1:12, nrow =3)
mat

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

# extract element from first row, first column
mat[1, 1]

## [1] 1

# extract all rows of first column
mat[, 1]

## [1] 1 2 3

# extract all columns of first row
mat[1,]

## [1]  1  4  7 10

# extract 2nd and 3rd row of first column
mat[c(2, 3), 1]

## [1] 2 3

# extract 2nd and 3rd column of first row
mat[1, c(2, 3)]

## [1] 4 7

# extract 2nd and 3rd row of first and third column
mat[c(2, 3), c(1, 3)]

##      [,1] [,2]
## [1,]    2    8
## [2,]    3    9

# row names
row_names <- c('row_1', 'row_2', 'row_3')

# column names
col_names <- c('col_1', 'col_2', 'col_3')

# matrix with row and column names
mat <- matrix(data = 1:9, nrow = 3, dimnames = list(row_names, col_names))

# extract elements from first row/columns
mat['row_1', 'col_1']

## [1] 1

# extract all rows of first column
mat[, 'col_1']

## row_1 row_2 row_3 
##     1     2     3

# extract all columns of first row
mat['row_1',]

## col_1 col_2 col_3 
##     1     4     7

# 3 x 4 matrix
mat <- matrix(data = 1:12, nrow =3)
mat

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

# elements greater than 4
mat > 4

##       [,1]  [,2] [,3] [,4]
## [1,] FALSE FALSE TRUE TRUE
## [2,] FALSE  TRUE TRUE TRUE
## [3,] FALSE  TRUE TRUE TRUE

# extract elements greater than 4
mat[mat > 4]

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

Dissolve Matrices

Till now we have learnt how to coerce a vector into matrix. Now let us learn how to coerce a matrix into a vector using:

• c()
• as.vector()

# 3 x 3 matrix
mat <- matrix(data = 1:9, nrow =3)
mat

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

# using c()
c(mat)

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

# using as.vector()
as.vector(mat)

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

Introduction

In the previous post, we learnt to index/subset vectors. In this post, we will learn to create matrices. A matrix is a regular array of data elements, arranged in rows and columns. Matrices in R are homogeneous i.e. they can hold a single type of data. Matrix elements are indexed by specifying the row and column index and the elements of a matrix can filled either by row or column. In the first section, we look at various ways of creating matrices in R.

Creating Matrix

The easiest way to create a matrix in R is to use the matrix() function. Let us look at its syntax:

args(matrix)

## function (data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL) 
## NULL

Now that we have understood the syntax of the matrix() function, let us create a simple numeric matrix.

# matrix of 3 rows filled by columns
mat <- matrix(data = 1:9, nrow = 3, byrow = FALSE)
mat

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

In the above example, we created a matrix of 3 rows where the data elements are filled by columns. We need to specify either the number of rows or columns and R will automatically compute the other. The number of data elements should be equal to the product of the rows and columns, else R will return a warning.

matrix(data = 1:9, nrow = 2, byrow = FALSE)

## Warning in matrix(data = 1:9, nrow = 2, byrow = FALSE): data length [9] is not a
## sub-multiple or multiple of the number of rows [2]

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

matrix(data = 1:10, nrow = 3, byrow = FALSE)

## Warning in matrix(data = 1:10, nrow = 3, byrow = FALSE): data length [10] is not
## a sub-multiple or multiple of the number of rows [3]

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

We can follow some general rules to avoid the mistakes made in the previous examples:

• if the number of elements is odd, both the number of rows and columns must be odd and their product should equal the number of data elements

• if the number of elements is even, either the number of rows or columns must be even. In some cases, both the rows and columns must be even

Let us continue to explore the syntax of the matrix() function.

matrix(data = 1:9, nrow = 3, byrow = TRUE)

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

matrix(data = 1:9, nrow = 3, byrow = FALSE)

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

matrix(data = 1:10, nrow = 2)

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

matrix(data = 1:10, ncol = 5)

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

Row & Column Names

You can specify names for the rows and columns of a matrix. To do so, we need to use list. Lists can contain other data structures such as vectors, matrices and even other lists. They are heterogeneous i.e. they can contain different data types. We will learn more about lists in a future post, for the time being let us learn how to create a basic list using the list() function:

# character vector
first_name <-   c("John", "Jill", "Jack")

# numeric vector
age <- c(20, 24, 32)

# list 
details <- list(first_name, age)
details

## [[1]]
## [1] "John" "Jill" "Jack"
## 
## [[2]]
## [1] 20 24 32

Now that we know how to create a list, let us go ahead and create a matrix and name its rows and columns.

# row names
row_names <- c('row_1', 'row_2', 'row_3')

# column names
col_names <- c('col_1', 'col_2', 'col_3')

# matrix with row and column names
matrix(data = 1:9, nrow = 3, dimnames = list(row_names, col_names))

##       col_1 col_2 col_3
## row_1     1     4     7
## row_2     2     5     8
## row_3     3     6     9

Matrix Dimension

Another useful function is dim(). It can be used to:

• check the dimension (rows and columns) of a matrix
• modify the dimension of a matrix
• coerce a vector to a matrix

mat <- matrix(data = 1:9, nrow = 3, byrow = TRUE)
dim(mat)

## [1] 3 3

# sample matrix
mat <- matrix(data = 1:12, nrow = 3, byrow = TRUE)
dim(mat)

## [1] 3 4

# change the dimension to 4 x 3
dim(mat) <- c(4, 3)
dim(mat)

## [1] 4 3

# numeric vector
vect1 <- 1:12
vect1

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

# coerce vect1 to a 4 x 3 matrix
dim(vect1) <- c(4, 3)
vect1

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

# numeric vector
vect1 <- 1:12
vect1

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

# coerce vect1 to a matrix
as.matrix(vect1)

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

Introduction

In the previous post, we learnt to perform simple operations on vector and handle missing values. In this post, we will learn to index/subset vectors.

Index Vectors

One of the most important steps in data analysis is selecting a subset of data from a bigger data set. Indexing helps in retrieving values individually or a set of values that meet a specific criteria. In this post, we look at various ways of indexing/subsetting vectors.

Index Operator

[] is the index operator in R. We can use various expressions within [] to subset data. In R, index positions begin at 1 and not 0. To begin with, let us look at values in different index positions:

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# return third element
vect1[3]

## [1] 2

# return seventh element
vect1[7]    

## [1] 10

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# return value at index 0
vect1[0]

## integer(0)

# length of the vector
length(vect1)

## [1] 10

# out of range index
vect1[11]   

## [1] NA

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# drop third element
vect1[-3]

## [1]  6  9  2 10  8  4  7  1  5

# drop seventh element
vect1[-7]   

## [1]  6  9  3  2 10  8  7  1  5

Subset Multiple Elements

If we do not specify anything within [], all the elements in the vector will be returned. We can specify the index elements using any expression that generates a sequence of integers. Let us look at a few examples:

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# return all elements
vect1[]

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

# return first 5 values
vect1[1:5]

## [1] 2 8 1 9 7

# return all values from the 5th position
end <- length(vect1)
vect1[5:end]

## [1]  7 10  5  4  3  6

If you are using the colon to generate the index positions, you will have to specify both the starting and ending position, else, R will return an error.

What if we want elements that are not in a sequence as we saw in the last example? In such cases, we have to create a vector using c() and use it to extract elements from the original vector. Below is an example:

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# extract 2nd, 5th and 7th element
select <- c(2, 5, 7)
vect1[select]

## [1] 4 9 5

# extract elements in position 1 to 4, 6 and 9
select <- c(1:4, 6, 9)
vect1[select]

## [1]  7  4 10  3  8  2

Subset Named Vectors

Vectors can be subset using the name of the elements. When using name of elements for subsetting, ensure that the names are enclosed in single or double quotations, else R will return an error. Let us look at a few examples:

vect1 <- c(score1 = 8, score2 = 6, score3 = 9)
vect1

## score1 score2 score3 
##      8      6      9

# extract score2
vect1['score2']

## score2 
##      6

# extract score1 and score3
vect1[c('score1', 'score3')]

## score1 score3 
##      8      9

Subset using logical values

Logical values can be used to subset vectors. They are not very flexible but can be used for simple indexing. In all of the below examples, the logical vectors are recycled to match the length of the vector from which we subset data:

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# returns all values
vect1[TRUE]

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

# empty vector
vect1[FALSE]

## integer(0)

# values in odd positions
vect1[c(TRUE, FALSE)]

## [1]  8  4 10  3  2

# values in even positions
vect1[c(FALSE, TRUE)]

## [1] 1 5 9 6 7

Subset using logical expressions

Logical expressions can be used to extract elements that meet specific criteria. This method is most flexible and useful as we can combine multiple conditions using relational and logical operators. Before we use logical expressions, let us spend some time understanding comparison and logical operators as we will be using them extensively hereafter.

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# return elements greater than 5
vect1 > 5

##  [1] FALSE FALSE  TRUE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE

vect1[vect1 > 5]

## [1]  9 10  8  6  7

# return elements greater than or equal to 5
vect1 >= 5

##  [1] FALSE FALSE  TRUE  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE

vect1[vect1 >= 5]

## [1]  9 10  5  8  6  7

# return elements lesser than 5
vect1 < 5

##  [1]  TRUE  TRUE FALSE FALSE FALSE FALSE  TRUE FALSE  TRUE FALSE

vect1[vect1 < 5]

## [1] 3 1 2 4

# return elements lesser than or equal to 5
vect1 <= 5

##  [1]  TRUE  TRUE FALSE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE

vect1[vect1 <= 5]

## [1] 3 1 5 2 4

# return elements equal to 5
vect1 == 5

##  [1] FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE FALSE

vect1[vect1 == 5]

## [1] 5

# return elements not equal to 5
vect1 != 5

##  [1]  TRUE  TRUE  TRUE  TRUE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

vect1[vect1 != 5]

## [1]  3  1  9 10  8  2  6  4  7

Logical Operators

Let us combine comparison and logical operators to create expressions and use them to subset vectors:

# random sample of 10 values
vect1 <- sample(10)
vect1

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

# return all elements less than 8 or divisible by 3
vect1[(vect1 < 8 | (vect1 %% 3 == 0))]

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

# return all elements less than 7 or divisible by 2
vect1[(vect1 < 7 | (vect1 %% 2 == 0))]

## [1]  3  2  5 10  4  8  6  1

Introduction

In the previous post, we learnt to create vectors of different data types. In this post, we will learn to

• coerce different data types
• perform simple operations on vectors
• handle missing data
• index/subset vectors

Naming Vector Elements

It is possible to name the different elements of a vector. The advantage of naming vector elements is that we can later on use these names to access the elements. Use names() to specify the names of a vector. You can specify the names while creating the vector or add them later.

# create vector and add names later
vect1 <- c(1, 2, 3)

# name the elements of the vector
names(vect1) <- c("One", "Two", "Three")

# call vect1
vect1
##   One   Two Three 
##     1     2     3

# specify names while creating vector
vect2 <- c(John = 1, Jack = 2, Jill = 3, Jovial = 4)

# call vect2
vect2
##   John   Jack   Jill Jovial 
##      1      2      3      4

Vector Coercion

Vectors are homogeneous i.e. all the elements of the vector must be of the same type. If we try to create a vector by combining different data types, the elements will be coerced to the most flexible type. The below table shows the order in which coercion occurs.

character data type is the most flexible while logical data type is the least flexible. If you try to combine any other data type with character, all the elements will be coerced to type character. In the absence of character data, all elements will be coerced to numeric. Finally, if the data does not include character or numeric types, all the elements will be coerced to integer type.

# vector of different data types
vect1 <- c(1, 1L, 'one', TRUE)

# call vect1
vect1
## [1] "1"    "1"    "one"  "TRUE"

# check data type
class(vect1)
## [1] "character"

# vector of different data types
vect1 <- c(1, 1L, TRUE)

# call vect1
vect1
## [1] 1 1 1

# check data type
class(vect1)
## [1] "numeric"

# vector of different data types
vect1 <- c(1L, TRUE)

# call vect1
vect1
## [1] 1 1

# check data type
class(vect1)
## [1] "integer"

Vector Operations

In this section, we look at simple operations that can be performed on vectors in R. Remember that the nature of the operations depends upon the type of data. Below are a few examples:

# create two vectors
vect1 <- c(1, 3, 8, 4)
vect2 <- c(2, 7, 1, 9)

# addition
vect1 + vect2
## [1]  3 10  9 13

# subtraction
vect1 - vect2
## [1] -1 -4  7 -5

# multiplication
vect1 * vect2
## [1]  2 21  8 36

# division
vect1 / vect2
## [1] 0.5000000 0.4285714 8.0000000 0.4444444

# create two vectors
vect1 <- c(2, 7)
vect2 <- c(1, 8, 5, 2)

# addition
vect1 + vect2
## [1]  3 15  7  9

# subtraction
vect1 - vect2
## [1]  1 -1 -3  5

# multiplication
vect1 * vect2
## [1]  2 56 10 14

# division
vect1 / vect2
## [1] 2.000 0.875 0.400 3.500

Missing Data

Missing data is a reality. No matter how careful you are in collecting data for your analysis, chances are always high that you end up with some missing data. In R missing values are represented by NA. In this section, we will focus on the following:

• test for missing data
• remove missing data
• exclude missing data from analysis

# vector with missing values
vect1 <- c(1, 3, NA, 5, 2)

# use is.na
is.na(vect1)
## [1] FALSE FALSE  TRUE FALSE FALSE

# use complete.cases
complete.cases(vect1)
## [1]  TRUE  TRUE FALSE  TRUE  TRUE

# vector with missing values
vect1 <- c(1, 3, NA, 5, 2)

# call vect1
vect1
## [1]  1  3 NA  5  2

# omit missing values
na.omit(vect1)
## [1] 1 3 5 2
## attr(,"na.action")
## [1] 3
## attr(,"class")
## [1] "omit"

# vector with missing values
vect1 <- c(1, 3, NA, 5, 2)

# compute mean
mean(vect1)
## [1] NA

# compute mean by excluding missing value
mean(vect1, na.rm = TRUE)
## [1] 2.75

Introduction

In the previous post, we learnt about the basic data types in R. IN this post, we will:

• understand the concept of vectors
• learn to create vectors of different data types

Vectors

Vector is the most basic data structure in R. It is a sequence of elements of the same data type. If the elements are of different data types, they will be coerced to a common type that can accommodate all the elements. Vectors are generally created using c() (concatenate function), although depending on the data type of vector being created, other methods can be used.

Numeric Vector

We will create a numeric vector using c() but you can use any function that creates a sequence of numbers. After that we will use is.vector() to check if it is a vector and class to check the data type.

# create a numeric vector
num_vect <- c(1, 2, 3)

# display the vector
num_vect

## [1] 1 2 3

# check if it is a vector
is.vector(num_vect)

## [1] TRUE

# check data type
class(num_vect)

## [1] "numeric"

Let us look at other ways to create a sequence of numbers. We leave it as an exercise to the reader to understand the functions using help.

# using colon
vect1 <- 1:10
vect1

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

# using rep
vect2 <- rep(1, 5)
vect2

## [1] 1 1 1 1 1

# using seq
vect3 <- seq(10)
vect3

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

Integer Vector

Creating an integer vector is similar to numeric vector except that we need to instruct R to treat the data as integer and not numeric or double. We will use the same methods we used for creating numeric vectors. To specify that the data is of type integer, we suffix the number with L.

# integer vector
int_vect <- c(1L, 2L, 3L)
int_vect

## [1] 1 2 3

# check data type
class(int_vect)

## [1] "integer"

# using colon
vect1 <- 1L:10L
vect1

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

# using rep
vect2 <- rep(1L, 5)
vect2

## [1] 1 1 1 1 1

# using seq
vect3 <- seq(10L)
vect3

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

Character Vector

A character vector may contain a single character, a word or a group of words. The elements must be enclosed in single or double quotations.

# character vector
greetings <- c("hello", "good morning")
greetings

## [1] "hello"        "good morning"

# check data type
class(greetings)

## [1] "character"

Logical Vector

A vector of logical values will either contain TRUE or FALSE or both.

# logical vector
vect_logic <- c(TRUE, FALSE, TRUE, TRUE, FALSE)
vect_logic

## [1]  TRUE FALSE  TRUE  TRUE FALSE

# check data type
class(vect_logic)

## [1] "logical"

In fact, you can create an integer vector and coerce it to type logical.

# integer vector
int_vect <- rep(0L:1L, 3)
int_vect

## [1] 0 1 0 1 0 1

# coerce to logical vector
log_vect <- as.logical(int_vect)
log_vect

## [1] FALSE  TRUE FALSE  TRUE FALSE  TRUE

# check data type
class(log_vect)

## [1] "logical"

Introduction

In the previous post, we learnt about getting help in R. In this post, we will learn about R packages. Packages are fundamental to R. There are approximately 15000 packages available on CRAN or the Comprehensive R Archive Network.

Packages are available for different topics. You should always look for a package before writing code from scratch. In case you have written your own codes for a new analysis or topic, do share it with the R community by converting the code into a package. You can learn more about building R packages from R Packages, a book written by Hadley Wickham.

In this post, we will learn to:

• install R packages from
  • CRAN
  • GitHub
  • BitBucket
  • Bioconductor
  • rForge
• install different versions of a package
• load, update & remove installed packages
• access package documentation

Install Packages

install.packages('ggplot2')

devtools::install_github("tidyverse/ggplot2")
remotes::install_github("tidyverse/dplyr")

devtools::install_bitbucket("dannavarro/lsr-package")
remotes::install_bitbucket("dannavarro/lsr-package")

install_bioc("SummarizedExperiment")

source('http://bioconductor.org/biocLite.R')
biocLite('GenomicFeatures')

install.packages('quantstrat', repos = 'https://r-forge.r-project.org/')

Install Different Versions

Now that we have learnt how to install packages, let us look at installing different versions of the same package.

remotes::install_version('dplyr', version = 0.5.0)

If you want to install the latest release from GitHub, append @*release to the repository name. For example, to install the latest release of dplyr:

remotes::install_github('tidyverse/dplyr@*release')

Installed Packages

• installed.packages(): view currently installed packages
• library(‘package_name’): load packages
• autoload(‘function_name’, ‘package_name’): load functions and data from packages only when called in the script
• available.package(): packages available for installation
• old.packages(): packages which have new versions available
• new.packages(): packages already not installed
• update.packages(): update packages which have new versions
• remove.packages(‘package_name’): remove installed packages

Library Paths

Library is a directory that contains all installed packages. Usually there will be more than one R library in your systme. You can find the location of the libraries using .libPaths().

.libPaths()

## [1] "C:/Users/HP/Documents/R/win-library" "C:/Program Files/R/R-4.0.0/library"

You can use lib.loc when you want to install, load, update and remove packages from a particular library.

install.packages('stringr', lib.loc = "C:/Program Files/R/R-3.4.1/library")

library(lubridate, lib.loc = "C:/Program Files/R/R-3.4.1/library")

update.packages(lib.loc = "C:/Program Files/R/R-3.4.1/library")

remove.packages(lib.loc = "C:/Program Files/R/R-3.4.1/library")

Introduction

In the previous post, we learnt how to create variables in R. In this post, we will learn about the following data types:

• numeric/double
• integer
• character
• logical
• date/time

Numeric

In R, numbers are represented by the data type numeric. We will first create a variable and assign it a value. Next we will learn a few methods of checking the type of the variable.

# create two variables
number1 <- 3.5
number2 <- 3

# check data type
class(number1)

## [1] "numeric"

class(number2)

## [1] "numeric"

# check if data type is numeric
is.numeric(number1)

## [1] TRUE

is.numeric(number2)

## [1] TRUE

If you carefully observe, integers are also treated as numeric/double. We will learn to create integers in a while. In the meanwhile, we have introduced two new funtions in the above example:

• class(): returns the class or type
• is.numeric(): tests whether the variable is of type numeric

Integer

Unless specified otherwise, integers are treated as numeric or double. In this section, we will learn to create variables of the type integer and to convert other data types to integer.

• create a variable number1 and assign it the value 3
• check the data type of number1 using class
• create a second variable number2 using as.integer and assign it the value 3
• check the data type of number2 using class
• finally use is.integer to check the data type of both number1 and number2

# create a variable and assign it an integer value
number1 <- 3

# create another variable using as.integer
number2 <- as.integer(3)

# check the data type
class(number1)

## [1] "numeric"

class(number2)

## [1] "integer"

# use is.integer to check data type
is.integer(number1)

## [1] FALSE

is.integer(number2)

## [1] TRUE

Character

Letters, words and group of words are represented by the data type character. All data of type character must be enclosed in single or double quotation marks. In fact any value enclosed in quotes will be treated as character. Let us create two variables to store the first and last name of a some random guy.

# first name
first_name <- "jovial"

# last name
last_name <- 'mann'

# check data type
class(first_name)

## [1] "character"

class(last_name)

## [1] "character"

# use is.charactert to check data type
is.character(first_name)

## [1] TRUE

is.character(last_name)

## [1] TRUE

You can coerce any data type to character using as.character().

# create variable of different data types
age <- as.integer(30) # integer
score <- 9.8          # numeric/double
opt_course <- TRUE    # logical
today <- Sys.time()   # date time

as.character(age) 

## [1] "30"

as.character(score)

## [1] "9.8"

as.character(opt_course)

## [1] "TRUE"

as.character(today)

## [1] "2020-06-10 18:20:48"

Logical

Logical data types take only 2 values. Either TRUE or FALSE. Sich data types are created when we compare two objects in R using comparison or logical operators.

• create two variables x and y
• assign them the values TRUE and FALSE respectively
• use is.logical to check data type
• use as.logical to coerce other data types to logical

# create variables x and y
x <- TRUE
y <- FALSE

# check data type
class(x)

## [1] "logical"

is.logical(y)

## [1] TRUE

The outcome of comparison operators is always logical. In the below example, we compare two numbers to see the outcome.

# create two numeric variables
x <- 3
y <- 4

# compare x and y
x > y

## [1] FALSE

x < y

## [1] TRUE

# store the result
z <- x > y
class(z)

## [1] "logical"

TRUE is represented by all numbers except 0. FALSE is represented only by 0 and no other numbers.

# TRUE and FALSE are represented by 1 and 0
as.logical(1)

## [1] TRUE

as.logical(0)

## [1] FALSE

# using numbers
as.numeric(TRUE)

## [1] 1

as.numeric(FALSE)

## [1] 0

# using different numbers
as.logical(-2, -1.5, -1, 0, 1, 2)

## [1] TRUE

Use as.logical() to coerce other data types to logical.

# create variable of different data types
age <- as.integer(30) # integer
score <- 9.8          # numeric/double
opt_course <- TRUE    # logical
today <- Sys.time()   # date time

as.logical(age) 

## [1] TRUE

as.logical(score)

## [1] TRUE

as.logical(opt_course)

## [1] TRUE

as.logical(today)

## [1] TRUE

Summary

• numeric, integer, character, logical and date are the basic data types in R
• class() or typeof() return the data type
• is.data_type checks whether the data is of the specified data type
  • is.numeric()
  • is.integer()
  • is.character()
  • is.logical()
  • is.date()
• as.data_type will coerce objects to the specified data type
  • as.numeric()
  • as.integer()
  • as.character()
  • as.logical()
  • as.date()

Introduction

In the previous post, we learnt to install RStudio. In this post, we will learn about variables and data types. You can skip this post, if you have prior experience in any other programming language.

What is a variable?

• variables are the fundamental elements of any programming language
• they are used to represent values that are likely to change
• they reference memory locations that store information/data

Let us use a simple case study to understand variables. Suppose you are computing the area of a circle whose radius is 3. In R, you can do this straight away as shown below:

3.14 * 3 * 3

## [1] 28.26

But you cannot reuse the radius or the area computed in any other analysis or computation. Let us see how variables can change the above scenario and help us in reusing values and computations.

Creating Variables

A variable consists of 3 components:

• variable name
• assignment operator
• variable value

We can store the value of the radius by creating a variable and assigning it the value. In this case, we create a variable called radius and assign it the value 3 using the assignment operator <-.

radius <- 3
radius

## [1] 3

Now that we have learnt to create variables, let us see how we can use them for other computations. For our case study, we will use the radius variable to compute the area of a circle.

Using Variables

We will create two variables, radius and pi, and use them to compute the area of a circle and store it in another variable area.

# assign value 3 to variable radius
radius <- 3

# assign value 3.14 to variable pi
pi <- 3.14

# compute area of circle
area <- pi * radius * radius

# call radius
radius

## [1] 3

# call area 
area

## [1] 28.26

Components of a Variable

Naming Conventions

• Name must begin with a letter. Do not use numbers, dollar sign ($) or underscore (_).
• The name can contain numbers or underscore. Do not use dash (-) or period (.).
• Do not use the names of keywords and avoid using the names of built in functions.
• Variables are case sensitive; average and Average would be different variables.
• Use names that are descriptive. Generally, variable names should be nouns.
• If the name is made of more than one word, use underscore to separate the words.

Recap..

• Variables are the building blocks of a programming language
• Variables reference memory locations that store information/data
• An assignment operator <- assigns values to a variable
• A variable has the following components:
  • name
  • memory address
  • value
  • data type
• Certain rules must be followed while naming variables