R Tutorial

R is a programming language and software environment for statistical analysis, graphics representation and reporting. R was created by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, and is currently developed by the R Development Core Team. R is freely available under the GNU General Public License, and pre-compiled binary versions are provided for various operating systems like Linux, Windows and Mac. This programming language was named R, based on the first letter of first name of the two R authors (Robert Gentleman and Ross Ihaka), and partly a play on the name of the Bell Labs Language S.

Audience

This tutorial is designed for software programmers, statisticians and data miners who are looking forward for developing statistical software using R programming. If you are trying to understand the R programming language as a beginner, this tutorial will give you enough understanding on almost all the concepts of the language from where you can take yourself to higher levels of expertise.

Prerequisites

Before proceeding with this tutorial, you should have a basic understanding of Computer Programming terminologies. A basic understanding of any of the programming languages will help you in understanding the R programming concepts and move fast on the learning track.

Overview

R is a programming language and software environment for statistical analysis, graphics representation and reporting. R was created by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, and is currently developed by the R Development Core Team.

The core of R is an interpreted computer language which allows branching and looping as well as modular programming using functions. R allows integration with the procedures written in the C, C++, .Net, Python or FORTRAN languages for efficiency.

R is freely available under the GNU General Public License, and pre-compiled binary versions are provided for various operating systems like Linux, Windows and Mac.

R is free software distributed under a GNU-style copy left, and an official part of the GNU project called GNU S.

Evolution of R

R was initially written by Ross Ihaka and Robert Gentleman at the Department of Statistics of the University of Auckland in Auckland, New Zealand. R made its first appearance in 1993.

A large group of individuals has contributed to R by sending code and bug reports.

Since mid-1997 there has been a core group (the "R Core Team") who can modify the R source code archive.

Features of R

As stated earlier, R is a programming language and software environment for statistical analysis, graphics representation and reporting. The following are the important features of R ???

  R is a well-developed, simple and effective programming language which includes conditionals, loops, user defined recursive functions and input and output facilities.

  R has an effective data handling and storage facility,

  R provides a suite of operators for calculations on arrays, lists, vectors and matrices.

  R provides a large, coherent and integrated collection of tools for data analysis.

  R provides graphical facilities for data analysis and display either directly at the computer or printing at the papers.

As a conclusion, R is world's most widely used statistics programming language. It's the # 1 choice of data scientists and supported by a vibrant and talented community of contributors. R is taught in universities and deployed in mission critical business applications. This tutorial will teach you R programming along with suitable examples in simple and easy steps.

Let’s get started.

/——————————————————————————/ ENVIRONMENT SETUP /——————————————————————————/

You can download the Windows installer version of R from R-3.2.2 for Windows (32/64 bit) and save it in a local directory.

As it is a Windows installer (.exe) with a name "R-version-win.exe". You can just double click and run the installer accepting the default settings. If your Windows is 32-bit version, it installs the 32-bit version. But if your windows is 64-bit, then it installs both the 32-bit and 64-bit versions.

After installation you can locate the icon to run the Program in a directory structure "R\R3.2.2\bin\i386\Rgui.exe" under the Windows Program Files. Clicking this icon brings up the R-GUI which is the R console to do R Programming.
This will show:
  R version 3.5.1 (2018-07-02) -- "Feather Spray"
  Copyright (C) 2018 The R Foundation for Statistical Computing
  Platform: x86_64-w64-mingw32/x64 (64-bit)

  R is free software and comes with ABSOLUTELY NO WARRANTY.
  You are welcome to redistribute it under certain conditions.
  Type 'license()' or 'licence()' for distribution details.
  
  R is a collaborative project with many contributors.
  Type 'contributors()' for more information and
  'citation()' on how to cite R or R packages in publications.
  
  Type 'demo()' for some demos, 'help()' for on-line help, or
  'help.start()' for an HTML browser interface to help.
  Type 'q()' to quit R.
  >

/———————————————————————————–/ BASIC SYNTAX /———————————————————————————–/

As a convention, we will start learning R programming by writing a "Hello, World!" program. Depending on the needs, you can program either at R command prompt or you can use an R script file to write your program. Let's check both one by one.

R Command Prompt

Once you have R environment setup, then it's easy to start your R command prompt by just typing the following command at your command prompt:

This will launch R interpreter and you will get a prompt > where you can start typing your program as follows:

myString <- "Hello, World!"
print ( myString)

[1] "Hello, World!"

Comments

Comments are like helping text in your R program and they are ignored by the interpreter while executing your actual program. Single comment is written using # in the beginning of the statement as follows:

# My first program in R Programming

/————————————————————————————-/ DATA TYPES /————————————————————————————-/

Generally, while doing programming in any programming language, you need to use various variables to store various information. Variables are nothing but reserved memory locations to store values. This means that, when you create a variable you reserve some space in memory.

You may like to store information of various data types like character, wide character, integer, floating point, double floating point, Boolean etc. Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory.

Topics:

Logical, Numeric, Integer, Complex, character, Raw

# Logical
# Example: TRUE OR FALSE
v <- TRUE 
print(class(v))

[1] "logical"

# Numeric
# Example: 12.3, 5, 999
v <- 23.5
print(class(v))

[1] "numeric"

# Integer
# Example: 2L, 34L, 0L
v <- 2L
print(class(v))

[1] "integer"

# Complex
# Example: 3 + 2i
v <- 2+5i
print(class(v))

[1] "complex"

# Character
# Example: 'a' , '"good", "TRUE", '23.4'
v <- "TRUE"
print(class(v))

[1] "character"

# Raw
# Example: "Hello" is stored as 48 65 6c 6c 6f
v <- charToRaw("Hello")
print(class(v))

[1] "raw"

Other topics:

Vectors, Lists, Matrices, Arrays, Factors, Data Frames

Vectors

When you want to create vector with more than one element, you should use c() function which means to combine the elements into a vector.

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

[1] "red"    "green"  "yellow"

# Get the class of the vector.
print(class(apple))

[1] "character"

Lists

A list is an R-object which can contain many different types of elements inside it like vectors, functions and even another list inside it.

# Create a list.
list1 <- list(c(2,5,3),21.3,sin)
# Print the list.
print(list1)

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]
function (x)  .Primitive("sin")

Matrices

A matrix is a two-dimensional rectangular data set. It can be created using a vector input to the matrix function.

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a" 

Arrays

While matrices are confined to two dimensions, arrays can be of any number of dimensions. The array function takes a dim attribute which creates the required number of dimension. In the below example we create an array with two elements which are 3x3 matrices each.

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"

Factors

Factors are the r-objects which are created using a vector. It stores the vector along with the distinct values of the elements in the vector as labels. The labels are always character irrespective of whether it is numeric or character or Boolean etc. in the input vector. They are useful in statistical modeling.

Factors are created using the factor() function. The nlevels functions gives the count of levels.

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')
# Create a factor object.
factor_apple <- factor(apple_colors)
# Print the factor.
print(factor_apple)

[1] green  green  yellow red    red    red    green 
Levels: green red yellow

print(nlevels(factor_apple))

[1] 3

Data Frames

Data frames are tabular data objects. Unlike a matrix in data frame each column can contain different modes of data. The first column can be numeric while the second column can be character and third column can be logical. It is a list of vectors of equal length.

Data Frames are created using the data.frame() function.

# Create the data frame.
BMI <-  data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

/————————————————————————————–/ VARIABLES /————————————————————————————–/

A variable provides us with named storage that our programs can manipulate. A variable in R can store an atomic vector, group of atomic vectors or a combination of many Robjects. A valid variable name consists of letters, numbers and the dot or underline characters. The variable name starts with a letter or the dot not followed by a number.

Variable Assignment

The variables can be assigned values using leftward, rightward and equal to operator. The values of the variables can be printed using print() or cat() function. The cat() function combines multiple items into a continuous print output.

# Assignment using equal operator.
var.1 = c(0,1,2,3)           
# Assignment using leftward operator.
var.2 <- c("learn","R")   
# Assignment using rightward operator.   
c(TRUE,1) -> var.3           
print(var.1)

[1] 0 1 2 3

cat ("var.1 is ", var.1 ,"\n")

var.1 is  0 1 2 3 

cat ("var.2 is ", var.2 ,"\n")

var.2 is  learn R 

cat ("var.3 is ", var.3 ,"\n")

var.3 is  1 1 

Note: The vector c(TRUE,1) has a mix of logical and numeric class. So logical class is coerced to numeric class making TRUE as 1.

Data Type of a Variable

In R, a variable itself is not declared of any data type, rather it gets the data type of the R - object assigned to it. So R is called a dynamically typed language, which means that we can change a variable's data type of the same variable again and again when using it in a program.

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")

The class of var_x is  character 

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"\n")

  Now the class of var_x is  numeric 

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"\n")

   Next the class of var_x becomes  integer 

Finding Variables

To know all the variables currently available in the workspace we use the ls() function. Also the ls() function can use patterns to match the variable names.

print(ls())

 [1] "a"            "apple"        "apple_colors" "BMI"          "factor_apple" "list1"        "M"           
 [8] "myString"     "t"            "v"            "var.1"        "var.2"        "var.3"        "var_x"       

Deleting Variables

Variables can be deleted by using the rm() function. Below we delete the variable var.3. On printing the value of the variable error is thrown.

rm(var.3)
print(var.3)

Error in print(var.3) : object 'var.3' not found

All the variables can be deleted by using the rm() and ls() function together.

rm(list = ls())
print(ls())

character(0)

/—————————————————————————————/ Operators /—————————————————————————————/

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. R language is rich in built-in operators and provides following types of operators.

Types of Operators

We have the following types of operators in R programming:
  Arithmetic Operators
  Relational Operators
  Logical Operators
  Assignment Operators
  Miscellaneous Operators
  

Arithmetic Operators

Adds two vectors
Operator: +

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

[1] 10.0  8.5 10.0

Subtracts second vector from the first
Operator: -

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

[1] -6.0  2.5  2.0

Multiplies both vectors
Operator: *

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

[1] 16.0 16.5 24.0

Divide the first vector with the second
Operator: /

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

[1] 0.250000 1.833333 1.500000

Give the remainder of the first vector with the second
Operator: %%

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

[1] 2.0 2.5 2.0

The result of division of first vector with second (quotient)
Operator: %/%

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

[1] 0 1 1

The first vector raised to the exponent of second vector
Operator: ^

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

[1]  256.000  166.375 1296.000

Relational Operators

Each element of the first vector is compared with the corresponding element of the second vector. The result of comparison is a Boolean value.

Operator: >

Checks if each element of the first vector is greater than the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

[1] FALSE  TRUE FALSE FALSE

Operator: <

Checks if each element of the first vector is less than the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v < t)

[1]  TRUE FALSE  TRUE FALSE

Operator: ==

Checks if each element of the first vector is equal to the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

[1] FALSE FALSE FALSE  TRUE

Operator: <=

Checks if each element of the first vector is less than or equal to the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

[1]  TRUE FALSE  TRUE  TRUE

Operator: >=

Checks if each element of the first vector is greater than or equal to the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

[1] FALSE  TRUE FALSE  TRUE

Operator: !=

Checks if each element of the first vector is unequal to the corresponding element of the second vector.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

[1]  TRUE  TRUE  TRUE FALSE

Logical Operators

Following table shows the logical operators supported by R language. It is applicable only to vectors of type logical, numeric or complex. All numbers greater than 1 are considered as logical value TRUE.

Each element of the first vector is compared with the corresponding element of the second vector. The result of comparison is a Boolean value.

Operator: &

It is called Element-wise Logical AND operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if both the elements are TRUE.

v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

[1]  TRUE  TRUE FALSE  TRUE

Operator: |

It is called Element-wise Logical OR operator. It combines each element of the first vector with the corresponding element of the second vector and gives a output TRUE if one the elements is TRUE.

v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

[1]  TRUE FALSE  TRUE  TRUE

Operator: !

It is called Logical NOT operator. Takes each element of the vector and gives the opposite logical value.

v <- c(3,0,TRUE,2+2i)
print(!v)

[1] FALSE  TRUE FALSE FALSE

The logical operator && and || considers only the first element of the vectors and give a vector of single element as output.

Operator: &&

Called Logical AND operator. Takes first element of both the vectors and gives the TRUE only if both are TRUE.

v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

[1] TRUE

Operator: !!

Called Logical OR operator. Takes first element of both the vectors and gives the TRUE if one of them is TRUE.

v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

[1] FALSE

Assignment Operators

These operators are used to assign values to vectors.

Operator: <??? or = or <<???

Called Left Assignment

v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)

[1] 3+0i 1+0i 1+0i 2+3i

print(v2)

[1] 3+0i 1+0i 1+0i 2+3i

print(v3)

[1] 3+0i 1+0i 1+0i 2+3i

Operator: -> or ->>

Called Right Assignment

c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2 
print(v1)

[1] 3+0i 1+0i 1+0i 2+3i

print(v2)

[1] 3+0i 1+0i 1+0i 2+3i

Miscellaneous Operators

These operators are used to for specific purpose and not general mathematical or logical computation.

Operator: :

    Colon operator. It creates the series of numbers in sequence for a vector.

v <- 2:8
print(v) 

[1] 2 3 4 5 6 7 8

Operator: %in%

This operator is used to identify if an element belongs to a vector.

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 

[1] TRUE

print(v2 %in% t)

[1] FALSE

Operator: %*%

This operator is used to multiply a matrix with its transpose.

M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

     [,1] [,2]
[1,]   65   82
[2,]   82  117

/—————————————————————————————/ Operators /—————————————————————————————/

Decision making structures require the programmer to specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

If Statement

An if statement consists of a Boolean expression followed by one or more statements.

The basic syntax for creating an if statement in R is:

  if(boolean_expression) {
     // statement(s) will execute if the boolean expression is true.
  }
  

x <- 30L
if(is.integer(x)) {
   print("X is an Integer")
}

[1] "X is an Integer"

If…Else Statement

An if statement can be followed by an optional else statement which executes when the boolean expression is false.

The basic syntax for creating an if...else statement in R is:
  
  if(boolean_expression) {
     // statement(s) will execute if the boolean expression is true.
  } else {
     // statement(s) will execute if the boolean expression is false.
  }
  

x <- c("what","is","truth")
if("Truth" %in% x) {
   print("Truth is found")
} else {
   print("Truth is not found")
}

[1] "Truth is not found"

The if…else if…else Statement

The basic syntax for creating an if...else if...else statement in R is:
  
  if(boolean_expression 1) {
     // Executes when the boolean expression 1 is true.
  } else if( boolean_expression 2) {
     // Executes when the boolean expression 2 is true.
  } else if( boolean_expression 3) {
     // Executes when the boolean expression 3 is true.
  } else {
     // executes when none of the above condition is true.
  }
  

x <- c("what","is","truth")
if("Truth" %in% x) {
   print("Truth is found the first time")
} else if ("truth" %in% x) {
   print("truth is found the second time")
} else {
   print("No truth found")
}

[1] "truth is found the second time"

Switch Statement

A switch statement allows a variable to be tested for equality against a list of values. Each value is called a case, and the variable being switched on is checked for each case.

The basic syntax for creating a switch statement in R is:
  
  switch(expression, case1, case2, case3....)
  

x <- switch(
   3,
   "first",
   "second",
   "third",
   "fourth"
)
print(x)

[1] "third"

Loops

A loop statement allows us to execute a statement or group of statements multiple times and the following is the general form of a loop statement in most of the programming languages:

Repeat Loop

The Repeat loop executes the same code again and again until a stop condition is met.

The basic syntax for creating a repeat loop in R is:

  repeat { 
     commands 
     if(condition) {
        break
     }
  }
  

v <- c("Hello","loop")
cnt <- 2
repeat {
   print(v)
   cnt <- cnt+1
   
   if(cnt > 5) {
      break
   }
}

[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 

While Loop

The While loop executes the same code again and again until a stop condition is met.

The basic syntax for creating a while loop in R is:

  while (test_expression) {
     statement
  }
  

v <- c("Hello","while loop")
cnt <- 2
while (cnt < 7) {
   print(v)
   cnt = cnt + 1
}

[1] "Hello"      "while loop"
[1] "Hello"      "while loop"
[1] "Hello"      "while loop"
[1] "Hello"      "while loop"
[1] "Hello"      "while loop"

For Loop

A For loop is a repetition control structure that allows you to efficiently write a loop that needs to execute a specific number of times.

The basic syntax for creating a for loop statement in R is:

  for (value in vector) {
     statements
  }
  

v <- LETTERS[1:4]
for ( i in v) {
   print(i)
}

[1] "A"
[1] "B"
[1] "C"
[1] "D"

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Break Statement

The break statement in R programming language has the following two usages:

  When the break statement is encountered inside a loop, the loop is immediately terminated and program control resumes at the next statement following the loop.

  It can be used to terminate a case in the switch statement (covered in the next chapter).
  
The basic syntax for creating a break statement in R is:
  
  break
  

v <- c("Hello","loop")
cnt <- 2
repeat {
   print(v)
   cnt <- cnt + 1
    
   if(cnt > 5) {
      break
   }
}

[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 
[1] "Hello" "loop" 

Next Statement

The next statement in R programming language is useful when we want to skip the current iteration of a loop without terminating it. On encountering next, the R parser skips further evaluation and starts next iteration of the loop.

The basic syntax for creating a next statement in R is:
  
  next
  

v <- LETTERS[1:6]
for ( i in v) {
   
   if (i == "D") {
      next
   }
   print(i)
}

[1] "A"
[1] "B"
[1] "C"
[1] "E"
[1] "F"