Page Title

Tutorial 2

R Programming

Overview of R

R is an open source programming language and software environment for statistical computing. The R language is widely used among statisticians and data miners for developing statistical software and data analysis.

R can be regarded as an implementation of the S language which was developed at Bell Laboratories by Rick Becker, John Chambers and Allan Wilks, and also forms the basis of the S-PLUS systems.

R is great for machine learning, data visualization and analysis, and some areas of scientific computing.

Advantages of R

A major advantage that R has over many other statistical packages and is that it’s free in the sense of free software. R is both flexible and powerful.

It has an amazing ecosystem for developers and It has wide range of packages for data access, data cleaning or munging, performing Analysis, creating Reports etc.

Take Input and Print in R

The <- symbol is the assignment operator. Assign some value to a variable then you can do either auto-printing for the variables just typing its name or you can use explicit printing.

msg <- "Hello R Programming !"

You can do either auto-printing for the variables just typing its name

msg

Or you can use explicit printing:

print(msg)

Variables

Variables store values and are an important component in programming, especially for a data scientist.

A variable can store a number, an object, a statistical result, vector, dataset, a model prediction basically anything R outputs.

You can do either auto-printing for the variables just typing its name.

To declare a variable, we need to assign a variable name. The name should not have space. We can use _ to connect to words.

To add a value to the variable, use <- or =.

Syntax :

# First way to declare a variable: use the `<-`
name_of_variable <- value

# Second way to declare a variable: use the `=`
name_of_variable = value

For a variable to be valid, it should follow these rules :

1 - It should contain letters, numbers, and only dot or underscore characters.
2 - It should not start with a number (eg:- 2iota)
3 - It should not start with a dot followed by a number (eg:- .2iota)
4 - It should not start with an underscore (eg:- _iota)
5 - It should not be a reserved keyword.

Valid identifiers in R are : total, Sum, .work.with, this_is_accepted, Num6

Invalid identifiers in R : t0t@l, 5um, _ray, TRUE, .0n3

Reserved Keywords

Following are the reserved keywords in R

for	in	repeat	while
function	if	else	next
break	TRUE	FALSE	NULL
Inf	NaN	NA	NA_integer_
NA_real_	NA_complex_	NA_character_	...

NA :- Not Available is used to represent missing values.

NULL :- It represents a missing or an undefined value.

NaN :- It is a short form for Not a Number(eg:- 0/0).

TRUE/FALSE :- These are used to represent Logical values.

Inf :- It denotes Infinity(eg:- 1/0).

If else, repeat, while, function, for, in, next, and break :– These are Used as looping statements, conditional statements, and functions.

... :- It is used to pass argument settings from one function to another.

NA_integer_, NA_real_, NA_complex_, and NA_ character _:- These represent missing values of other atomic types.

Constants in R

Constants are entities within a program whose value can't be changed. There are 2 basic types of constant. These are numeric constants and character constants.

Numeric Constants :

All the numbers you will be using within a program fall under this category. There are sub types like integer, double or complex, which is checked usng typeof() function. Example:

> typeof (6)
[1] "double"

> typeof (4L)
[1] "integer"

Character Constants :

These can be signified by means of either single quotes (') or using double quotes (") as delimiters.

> 'Anant'
[1] "Anant"

> typeof("AJ")
[1] "character"

R Objects

R has five basic or "atomic" classes of objects:

1. Numeric – Also known as Double. The default type when dealing with numbers. – Examples: 1, 1.0, 42.5
2. Integer – Examples: 1L, 2L, 42L
3. Complex – Example: 4 + 2i
4. Logical – Two possible values: TRUE and FALSE – You can also use T and F, but this is not recommended. – NA is also considered logical.
5. Character – Examples: "a", "Statistics", "1 plus 2."

We can check the type of a variable with the class function

x <- 28
class(x)

y <- "R is Fantastic"
class(y)

z <- TRUE
class(z)

Output :

[1] "numeric"

[1] "character"

[1] "logical"

Other Objects:

Inf is infinity. You can have either positive or negative infinity.

Input:

1/0

Output:

[1] Inf

Input:

1/Inf

Output:

[1] 0

NaN means Not a number. It’s an undefined value.

Input:

0/0

Output:

[1] NaN

R Attributes

R objects can have attributes, which are like metadata for the object. These metadata can be very useful in that they help to describe the object.

1. names, dimnames
2. dimensions (e.g. matrices, arrays)
3. class (e.g. integer, numeric)
4. length
5. other user-defined attributes/metadata

Attributes of an object (if any) can be accessed using the attributes() function. Not all R objects contain attributes, in which case the attributes() function returns NULL.

attributes(iris) #iris is a dataset

R Data Structures

R also has a number of basic data structures. A data structure is either homogeneous (all elements are of the same data type) or heterogeneous (elements can be of more than one data type).

Dimension	Homogeneous	Heterogeneous
1	Vector	List
2	Matrix	Dataframes
3+	Array

The most basic type of R object is a vector. Empty vectors can be created with the vector() function. There is really only one rule about vectors in R, which is that A vector can only contain objects of the same class.

Vectors

A vector is a one-dimensional array. We can create a vector with all the basic data type we learnt before. The simplest way to build a vector in R, is to use the c command.

Example 1 :

vec_num <- c(1, 10, 49)
vec_num

Output :

> [1] 1 10 49

Example 2 :

vec_num <- c("a", "b", "c")
vec_num

Output :

> [1] "a" "b" "c"

R – Operators

R language has so many built-in operators to perform different arithmetic and logical operations. There are mainly 4 types of operators in R.

1. Arithmetic Operators
2. Relational Operators
3. Logical Operators
4. Assignment Operators
5. Mixed Operators

Arithmetic Operators

Below table shows the arithmetic operators in R.

Description	Operator
Addition	+
Subtraction	-
Multiplication	*
Division	/
Exponent	^
Modulus	%%
Integer Division	%/%

Example :

x <- 50
y <- 40

1 - x + y
2 - x - y
3 - x * y
4 - x / y
5 - x ^ y
6 - x %% y
7 - x %/% y

Output :

< x + y
[1] 90
< x - y
[1] 10
< x * y
[1] 2000
< x / y
[1] 1.25
< x %/% y
[1] 1
< x %% y
[1] 10
< x ^ y
[1] 9.094947e+67

Relational Operators

Below table shows the relational operators in R.

Description	Operator
Less Than	<
Greater Than	>
Less Than or Equal To	<=
Greater Than or Equal To	>=
Equal To	==
Not Equal To	!=

Example :

x <- 50
y <- 40

1 - x < y
2 - x > y
3 - x <= y
4 - x >= y
5 - x == y
6 - x != y

Output :

> x < y
[1] TRUE
> x > y
[1] FALSE
> x <= y
[1] TRUE
> x >= y
[1] FALSE
> x == y
[1] FALSE
> x != y
[1] TRUE

Logical Operators

Below table shows the logical operators in R.

Operators & and | perform element-wise operation producing result having length of the longer operand.

But && and || examines only the first element of the operands resulting into a single length logical vector.

Description	Operator
Logical NOT	!
Element wise Logical AND	&
Logical AND	&&
Element wise Logical OR	\|
Logical OR	\|\|

Example :

a <- c(TRUE,TRUE,FALSE,0,6,7)
b <- c(FALSE,TRUE,FALSE,TRUE,TRUE,TRUE)

a&b
a&&b
a|b
a||b
!a
!b

Output :

> a&b
[1] FALSE TRUE FALSE FALSE TRUE TRUE
> a&&b
[1] FALSE
> a|b
[1] TRUE TRUE FALSE TRUE TRUE TRUE
> a||b
[1] TRUE
> !a
[1] FALSE FALSE TRUE TRUE FALSE FALSE
> !b
[1] TRUE FALSE TRUE FALSE FALSE FALSE

In the above example, Zero is considered FALSE and non-zero numbers are taken as TRUE.

Assignment Operators

Below table shows the assignment operators in R. They are used to assign values to variables.

Description	Operator
Left Assignment	<-, <<-, =
Right Assignment	->, ->>

Example :

v1 <- 300
v2 <<- 400
v3 = 500
v4 <- c(1 : 20)

1000 -> v5
500 ->> v6
30 : 40 ->> v7

v1
v2
v3
v4
v5
v6
v7

Output :

> v1
[1] 300
> v2
[1] 400
> v3
[1] 500
> v4
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
> v5
[1] 1000
> v6
[1] 500
> v7
[1] 30 31 32 33 34 35 36 37 38 39 40
>

Mixed Operators

There are few other useful operators in R which are being used for specific purpose and not general mathematical or logical computation.

Operator	Description
:	Colon Operator. It creates a sequence of numbers
%in%	This operator is used to identify if an element belongs to a vector or not
%*%	This operator is used for matrix multiplication

Example :

x <- 1 : 10
y <- 8
z <-20

x
y %in% x
z %in% x

m <- matrix(1 : 9, 3, 3)
m %*% m
m * m

Output :

> x
[1] 1 2 3 4 5 6 7 8 9 10
> y %in% x
[1] TRUE
> z %in% x
[1] FALSE
>
> m <- matrix(1 : 9, 3, 3)
> m %*% m

	[,1]	[,2]	[,3]
[1,]	30	66	102
[2,]	36	81	126
[3,]	42	96	150

> m * m

	[,1]	[,2]	[,3]
[1,]	1	16	49
[2,]	4	25	64
[3,]	9	36	81

Control Structure

Control structures in R allow you to control the flow of execution of a series of R expressions.

Control structures allow you to respond to inputs or to features of the data and execute different R expressions accordingly.

Here are the Commonly used control structures in R:

Statement	Description
if and else	testing a condition and acting on it
switch	a substitute for long if statements that compare a variable to several integral values.
for	execute a loop a fixed number of times
while	execute a loop while a condition is true
repeat	execute an infinite loop (must break out of it to stop)
break	break the execution of a loop
next	skip an iteration of a loop

In the following section one by one control structure will be discussed.

If-else condition in R

if Statement:

The if-else combination is probably the most commonly used control structure not only in R but also for other programming languages.

This structure allows you to test a condition and act on it depending on whether it’s true or false.

The syntax of if statement is:

if (condition) {
#R Code
}

If the condition is TRUE, the statement gets executed. But if it’s FALSE, nothing happens.

if…else statement

if/else syntax is:

if (condition) {
#R Code
} else {
#R Code
}

Example :

age <- 25

if (age > 18) {
print('You are eligible to vote!')
} else {
print('Wait few year more')
}

Output :

> [1] "You are eligible to vote!"

Note : Make sure you correctly write the indentations. Code with multiple conditions can become unreadable when the indentations are not in correct position.

Nested if…else statement :

With elif, you can add as many conditions as we want. The syntax is:

if (condition1) {
expr1
} else if (condition2) {
expr2
} else if (condition3) {
expr3
} else {
expr4
}

Example :

quantity <- 10

if (quantity < 20) {
print('Not enough for today')
} else if (quantity > 20 && quantity <= 30) {
print('Average day')
} else {
print('What a great day!')
}

Output :

> [1] "Not enough for today"

ifelse() Function :

This is called Vectorization with ifelse. The ifelse() function is a vector equivalent form of the if…else statement in R. This vectorization of code, will be much faster than applying the same function to each element of the vector individually.

ifelse(4 > 3, "greater","less")

Output :

[1] "greater"

Switch case in R

Switch case statements are a substitute for long if statements that compare a variable to several integral values.

Switch case in R is a multiway branch statement. It allows a variable to be tested for equality against a list of values.

Switch statement follows the approach of mapping and searching over a list of values. If there is more than one match for a specific value, then the switch statement will return the first match found of the value matched with the expression.

Syntax:

switch(expression, case1, case2, case3....)

Important Points about Switch Case Statements:

An expression type with character string always matched to the listed cases.
An expression which is not a character string then this exp is coerced to integer.
For multiple matches, the first match element will be used.
No default argument case is available there in R switch case.
An unnamed case can be used, if there is no matched case.

Example:

# Following is a simple R program to demonstrate syntax of switch.

val <- switch(
4,
"AJ1",
"AJ2",
"AJ3",
"AJ4",
"AJ5",
"AJ6"
)
print(val)

Output :

[1] "AJ4"

Example: switch() Function with as String Expression

The expression used in the switch () function can be a string as well. In this case, the matching named item’s value is returned.

> switch("color", "color" = "red", "shape" = "square", "length" = 5)
[1] "red"

Here, "color" is a string which matches with the first item of the list. Hence, we are getting "red" as an output.

For loops

A for loop is very valuable when we need to iterate over a list of elements or a range of numbers.

Loop can be used to iterate over a list, data frame, vector, matrix or any other object. The braces and square bracket are compulsory.

Syntax :

for(i in vector) {
expression
}

Example :

for(i in 1:10) {
print(i)
}

Output :

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

For one line loops, the curly braces are not strictly necessary.

x <- c("a", "b", "c", "d")

for(i in 1:4) print(x[i])

Output :

[1] "a"
[1] "b"
[1] "c"
[1] "d"

Nested for loops:

for loops can be nested inside of each other like the below example.

x <- matrix(1:10, 5, 2)
for(i in seq_len(nrow(x))) {
for(j in seq_len(ncol(x))) {
print(x[i, j])
}
}

Output :

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

While loops

While loops begin by testing a condition. If it is true, then they execute the loop body. Once the loop body is executed, the condition is tested again, and so forth, until the condition is false, after which the loop exits.

Syntax :

while (condition) {
#R Code
}

Example :

count <- 0

while(count < 10) {
print(count)
count <- count + 1
}

Output :

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

Note : Remember to write a closing condition at some point otherwise the loop will go on indefinitely.

repeat loop

A repeat loop is used to iterate over a block of code multiple number of times. There is no condition check in repeat loop to exit the loop. The only way to exit a repeat loop is to call break.

These are not commonly used in statistical or data analysis applications but they do have their uses.

Syntax :

repeat {
#R Code

if(…){
#R Code
break
}
}

Example :

x <- 5

repeat {
print(x)
x = x + 1

if (x == 10){
break
}
}

Output :

[1] 5
[1] 6
[1] 7
[1] 8
[1] 9

next and break

next is used to skip the current iteration. It works like a continue statement.

Example of next:

for(i in 1 : 10) {

if(i <= 5) {
# Skip the first 5 iterations
next
}
print(i)
}

Output :

[1] 6
[1] 7
[1] 8
[1] 9
[1] 10

Break is used to break the loop after a point.

Example of break:

for(i in 1 : 100) {
print(i)

if(i > 3) {
print(i)
# Stop loop after 3 iterations
break
}
}

Output :

[1] 1
[1] 2
[1] 3
[1] 4
[1] 4

R Functions

Functions are used to logically break our code into simpler parts which become easy to maintain and understand.

The reserved word function is used to declare a function in R.

Example :

pow <- function(x, y) {
# function to print x raised to the power y

result <- x^y
print(paste(x, "raised to the power", y, "is", result))
}

Here, we created a function called pow().

It takes two arguments, finds the first argument raised to the power of second argument and prints the result in appropriate format.

We have used a built-in function paste() which is used to concatenate strings.

We can call the above function as follows.

> pow(10, 2)

Output :

[1] "10 raised to the power 2 is 100"

Here, the arguments used in the function declaration (x and y) are called formal arguments and those used while calling the function are called actual arguments.

Named Arguments

We can also call the function using named arguments.

When calling a function in this way, the order of the actual arguments doesn’t matter. For example, all of the function calls given below are equivalent.

> pow(10, 2)
[1] "10 raised to the power 2 is 100"

> pow(x = 10, y = 2)
[1] "10 raised to the power 2 is 100"

> pow(y = 2, x = 10)
[1] "8 raised to the power 2 is 100"

We can also use named and unnamed arguments in a single call.

In such case, all the named arguments are matched first and then the remaining unnamed arguments are matched in a positional order.

> pow(x = 10, 2)
[1] "10 raised to the power 2 is 100"

> pow(2, x = 10)
[1] "8 raised to the power 2 is 100"

In all the examples above, x gets the value 8 and y gets the value 2.

Default Values for Arguments :

We can assign default values to arguments in a function in R.

This is done by providing an appropriate value to the formal argument in the function declaration.

Here is the above function with a default value for y.

pow <- function(x, y = 2) {
# function to print x raised to the power y
result <- x^y
print(paste(x,"raised to the power", y, "is", result))
}

The use of default value to an argument makes it optional when calling the function.

> pow(10)
[1] "10 raised to the power 2 is 100"

> pow(10, 1)
[1] "10 raised to the power 1 is 10"

Return Value from Function

Many a times, we will require our functions to do some processing and return back the result. This is accomplished with the return() function in R.

Syntax of return()

return(expression)

Example :

Let us look at an example which will return whether a given number is positive, negative or zero.

check <- function(x) {
if (x > 0) {
result <- "Positive"
} else if (x < 0) {
result <- "Negative"
} else {
result <- "Zero"
}
return(result)
}

Here are some samples :

> check(1)
[1] "Positive"

> check(-10)
[1] "Negative"

> check(0)
[1] "Zero"

Functions without return()

If there are no explicit returns from a function, the value of the last evaluated expression is returned automatically in R.

For example, the following is equivalent to the above function.

check <- function(x) {
if (x > 0) {
result <- "Positive"
} else if (x < 0) {
result <- "Negative"
} else {
result <- "Zero"
}

result
}

Multiple Returns

The return() function can return only a single object. If we want to return multiple values in R, we can use a list (or other objects) and return it.

Example :

multi_return <- function() {
my_list <- list("color" = "red", "size" = 20, "shape" = "round")
return(my_list)
}

Here, we create a list my_list with multiple elements and return this single list.

> a <- multi_return()
> a$color
[1] "red"
> a$size
[1] 20
> a$shape
[1] "round"

Tutorial 2 - R Programming