UNIT - III

R - Vectors
Vectors in R are the same as the arrays in C language which are used to hold multiple data
values of the same type. One major key point is that in R the indexing of the vector will start
from ‘1’ and not from ‘0’. We can create numeric vectors and character vectors as well.

Vector Creation
Single Element Vector
Even when you write just one value in R, it becomes a vector of length 1 and belongs to one of
the above vector types.

# Atomic vector of type character.

print("abc");

# Atomic vector of type double.

print(12.5)

# Atomic vector of type integer.

print(63L)

# Atomic vector of type logical.

print(TRUE)

# Atomic vector of type complex.

print(2+3i)

# Atomic vector of type raw.

print(charToRaw('hello'))
 Multiple Elements Vector
Using colon operator with numeric data

# Creating a sequence from 5 to 13.

v <- 5:13

print(v)

# Creating a sequence from 6.6 to 12.6.

v <- 6.6:12.6

print(v)

# If the final element specified does not belong to the sequence then it is discarded.

v <- 3.8:11.4

print(v)

Using sequence (Seq.) operator

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

When we execute the above code, it produces the following result −

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

Using the c() function

The non-character values are coerced to character type if one of the elements is a character.
# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)
When we execute the above code, it produces the following result −
[1] "apple" "red" "5" "TRUE"
Accessing Vector Elements
Elements of a Vector are accessed using indexing. The [ ] brackets are used for indexing.
Indexing starts with position 1. Giving a negative value in the index drops that element from
result.TRUE, FALSE or 0 and 1 can also be used for indexing.
# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.

v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.

x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.

y <- t[c(0,0,0,0,0,0,1)]
print(y)

When we execute the above code, it produces the following result −

[1] "Mon" "Tue" "Fri"

[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"
 Vector Manipulation
Vector arithmetic
Two vectors of same length can be added, subtracted, multiplied or divided giving the result
as a vector output.
# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector subtraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

Vector Element Recycling

If we apply arithmetic operations to two vectors of unequal length, then the elements of the
shorter vector are recycled to complete the operations.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)
add.result <- v1+v2
print(add.result)

sub.result <- v1-v2

print(sub.result)

Vector Element Sorting

Elements in a vector can be sorted using the sort() function.
v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.

result <- sort(v)
print(result)

# Sort the elements in the reverse order.

result <- sort(v, decreasing = TRUE)
print(result)

# Sorting character vectors.

v <- c("Red","Blue","yellow","violet")
result <- sort(v)
print(result)

# Sorting character vectors in reverse order

result <- sort(v, decreasing = TRUE)
print(result)

Types of vectors
Vectors are of different types which are used in R. Following are some of the types of
vectors:
 Numeric vectors
Numeric vectors are those which contain numeric values such as integer, float, etc.

# R program to create numeric Vectors

# creation of vectors using c() function.
v1 <- c(4, 5, 6, 7)
# display type of vector
typeof(v1)

# by using 'L' we can specify that we want integer values.

v2 <- c(1L, 4L, 2L, 5L)
# display type of vector
typeof(v2)

Output:
[1] "double"
[1] "integer"
 Character vectors
Character vectors contain alphanumeric values and special characters.

# R program to create Character Vectors

# by default numeric values
# are converted into characters
v1 <- c('geeks', '2', 'hello', 57)
# Displaying type of vector
typeof(v1)

Output:
[1] "character"
 Logical vectors
Logical vectors contain boolean values such as TRUE, FALSE and NA for Null
values.

# R program to create Logical Vectors

# Creating logical vector

# using c() function

v1 <- c(TRUE, FALSE, TRUE, NA)

 # Displaying type of vector

typeof(v1)

 Output:
[1] "logical"

Modifying a vector
Modification of a Vector is the process of applying some operation on an individual element
of a vector to change its value in the vector. There are different ways through which we can
modify a vector:

X <- c(2, 7, 9, 7, 8, 2)

# modify a specific element

X[3] <- 1

X[2] <-9

cat('subscript operator', X, '\n')

# Modify using different logics.

X[X>5] <- 0

cat('Logical indexing', X, '\n')

# Modify by specifying

# the position or elements.

X <- X[c(3, 2, 1)]

cat('combine() function', X)

Output
subscript operator 2 9 1 7 8 2
Logical indexing 2 0 1 0 0 2
combine() function 1 0 2

Deleting a vector
Deletion of a Vector is the process of deleting all of the elements of the vector. This can be
done by assigning it to a NULL value.

M <- c(8, 10, 2, 5)

# set NULL to the vector
M <- NULL
cat('Output vector', M)

Output:
Output vector NULL

Sorting elements of a Vector

sort() function is used with the help of which we can sort the values in ascending or
descending order.

# R program to sort elements of a Vector

# Creation of Vector

X <- c(8, 2, 7, 1, 11, 2)

# Sort in ascending order

A <- sort(X)

cat('ascending order', A, '\n')

# sort in descending order

# by setting decreasing as TRUE

B <- sort(X, decreasing = TRUE)

 cat('descending order', B)

Output:
ascending order 1 2 2 7 8 11
descending order 11 8 7 2 2 1

Creating named vectors

Named vector can be created in several ways. With c :

xc <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

which results in:

> xc
abcd
5678

With the setNames function, two vectors of the same length can be used to create a named
vector:

x <- 5:8
y <- letters[1:4]

xy <- setNames(x, y)
which results in a named integer vector:

> xy
abcd
5678

You may also use the names function to get the same result:

xy <- 5:8
names(xy) <- letters[1:4]
#With such a vector it is also possibly to select elements by name:
xy["a"]

Vector sub-setting
In R Programming Language, subsetting allows the user to access elements from an object. It
takes out a portion from the object based on the condition provided.
Method 1: Subsetting in R Using [ ] Operator
Using the ‘[ ]’ operator, elements of vectors and observations from data frames can be
accessed. To neglect some indexes, ‘-‘ is used to access all other indexes of vector or data
frame.
x <- 1:15
# Print vector
cat("Original vector: ", x, "\n")
# Subsetting vector
cat("First 5 values of vector: ", x[1:5], "\n")
cat("Without values present at index 1, 2 and 3: ", x[-c(1, 2, 3)], "\n")

Method 4: Subsetting in R Using subset() Function

subset() function in R programming is used to create a subset of vectors, matrices, or data
frames based on the conditions provided in the parameters.
q <- subset(airquality, Temp < 65, select = c(Month))
print(q)

Matrices
Matrix is a rectangular arrangement of numbers in rows and columns. In a matrix, as we
know rows are the ones that run horizontally and columns are the ones that run vertically.
Creating and Naming a Matrix
To create a matrix in R you need to use the function called matrix(). The arguments to
this matrix() are the set of elements in the vector. You have to pass how many numbers of
rows and how many numbers of columns you want to have in your matrix.

Note: By default, matrices are in column-wise order.

A = matrix(

# Taking sequence of elements

c(1, 2, 3, 4, 5, 6, 7, 8, 9),

# No of rows
nrow = 3,

# No of columns
ncol = 3,
 # By default matrices are in column-wise order
# So this parameter decides how to arrange the matrix
byrow = TRUE
)

# Naming rows
rownames(A) = c("r1", "r2", "r3")

# Naming columns
colnames(A) = c("c1", "c2", "c3")

cat("The 3x3 matrix:\n")

print(A)

Creating special matrices

R allows creation of various different types of matrices with the use of arguments passed to
the matrix() function.

 Matrix where all rows and columns are filled by a single constant ‘k’:
To create such a matrix the syntax is given below:

Syntax: matrix(k, m, n)
Parameters:
k: the constant
m: no of rows
n: no of columns

print(matrix(5, 3, 3))
Diagonal matrix:
A diagonal matrix is a matrix in which the entries outside the main diagonal are all zero. To
create such a matrix the syntax is given below:
print(diag(c(5, 3, 3), 3, 3))
Identity matrix:
A square matrix in which all the elements of the principal diagonal are ones and all other
elements are zeros. To create such a matrix the syntax is given below:
print(diag(1, 3, 3))
Matrix metrics
Matrix metrics mean once a matrix is created then

 How can you know the dimension of the matrix?

 How can you know how many rows are there in the matrix?
 How many columns are in the matrix?
 How many elements are there in the matrix? are the questions we generally wanted to
answer.
A = matrix(
c(1, 2, 3, 4, 5, 6, 7, 8, 9),
nrow = 3,
ncol = 3,
byrow = TRUE
)
cat("The 3x3 matrix:\n")
print(A)

cat("Dimension of the matrix:\n")

print(dim(A))

cat("Number of rows:\n")
print(nrow(A))

cat("Number of columns:\n")
print(ncol(A))

cat("Number of elements:\n")
print(length(A))
# OR
print(prod(dim(A)))

Matrix subsetting
A matrix is subset with two arguments within single brackets, [], and separated by a comma.
The first argument specifies the rows, and the second the columns.

M_new<-matrix(c(25,23,25,20,15,17,13,19,25,24,21,19,20,12,30,17),ncol=4)

#M_new<-matrix(1:16,4)
M_new
colnames(M_new)<-c("C1","C2","C3","C4")
rownames(M_new)<-c("R1","R2","R3","R4")

M_new[,1,drop=FALSE] # all rows with 1st column

M_new[1,,drop=FALSE] #1st row with all column

M_new[1,1,drop=FALSE] #display 1st row and 1st column, cell value

M_new[1:2,2:3]#display 1st ,2nd rows and 2nd ,3rd column

M_new[1:2,c(2,4)] #display 1st ,2nd rows and 2nd ,4th column

Arrays
Arrays are the R data objects which can store data in more than two dimensions. For example
− If we create an array of dimension (2, 3, 4) then it creates 4 rectangular matrices each with 2
rows and 3 columns. Arrays can store only data type.

An array is created using the array() function. It takes vectors as input and uses the values in
the dim parameter to create an array.
Example
The following example creates an array of two 3x3 matrices each with 3 rows and 3 columns.

# Create two vectors of different lengths.

vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.

result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

Naming Columns and Rows

We can give names to the rows, columns and matrices in the array by using the dimnames
parameter.
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.

result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
matrix.names))
print(result)

Accessing arrays
The arrays can be accessed by using indices for different dimensions separated by commas.
Different components can be specified by any combination of elements’ names or positions.

Accessing Uni-Dimensional Array

The elements can be accessed by using indexes of the corresponding elements.

vec <- c(1:10)

# accessing entire vector

cat ("Vector is : ", vec)

# accessing elements
cat ("Third element of vector is : ", vec[3])

Accessing Array Elements

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.

result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
column.names, matrix.names))

# Print the third row of the second matrix of the array.

print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.

print(result[,,2])

Calculations across Array Elements

We can do calculations across the elements in an array using the apply() function.
Syntax
apply(x, margin, fun)
Following is the description of the parameters used −
 x is an array.
 margin is the name of the data set used.
 fun is the function to be applied across the elements of the array.
Example
We use the apply() function below to calculate the sum of the elements in the rows of an array
across all the matrices.
# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.

new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)
When we execute the above code, it produces the following result −

,,1
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15
,,2
[,1] [,2] [,3]
[1,] 5 10 13
[2,] 9 11 14
[3,] 3 12 15

[1] 56 68 60
Accessing subset of array elements
A smaller subset of the array elements can be accessed by defining a range of row or column
limits.

row_names <- c("row1", "row2")

col_names <- c("col1", "col2", "col3", "col4")
mat_names <- c("Mat1", "Mat2")
arr = array(1:15, dim = c(2, 4, 2),
dimnames = list(row_names, col_names, mat_names))

# print elements of both the rows and columns 2 and 3 of matrix 1

print (arr[, c(2, 3), 1])

Adding elements to array

Elements can be appended at the different positions in the array. The sequence of elements is
retained in order of their addition to the array. The time complexity required to add new
elements is O(n) where n is the length of the array. The length of the array increases by the
number of element additions. There are various in-built functions available in R to add new
values:

c(vector, values): c() function allows us to append values to the end of the array. Multiple
values can also be added together.
append(vector, values): This method allows the values to be appended at any position in the
vector. By default, this function adds the element at end.
append(vector, values, after=length(vector)) adds new values after specified length of the
array specified in the last argument of the function.

Using the length function of the array:

Elements can be added at length+x indices where x>0.
# creating a uni-dimensional array
x <- c(1, 2, 3, 4, 5)

# addition of element using c() function

x <- c(x, 6)
print ("Array after 1st modification ")
print (x)

# addition of element using append function

x <- append(x, 7)
print ("Array after 2nd modification ")
print (x)

# adding elements after computing the length

len <- length(x)
x[len + 1] <- 8
print ("Array after 3rd modification ")
print (x)

# adding on length + 3 index

x[len + 3]<-9
print ("Array after 4th modification ")
print (x)

# append a vector of values to the array after length + 3 of array

print ("Array after 5th modification")
x <- append(x, c(10, 11, 12), after = length(x)+3)
print (x)

# adds new elements after 3rd index

print ("Array after 6th modification")
x <- append(x, c(-1, -1), after = 3)
print (x)
[1] "Array after 1st modification "
[1] 1 2 3 4 5 6
[1] "Array after 2nd modification "
[1] 1 2 3 4 5 6 7
[1] "Array after 3rd modification "
[1] 1 2 3 4 5 6 7 8
[1] "Array after 4th modification "
[1] 1 2 3 4 5 6 7 8 NA 9
[1] "Array after 5th modification"
[1] 1 2 3 4 5 6 7 8 NA 9 10 11 12
[1] "Array after 6th modification"
[1] 1 2 3 -1 -1 4 5 6 7 8 NA 9 10 11 12
Removing Elements from Array
Elements can be removed from arrays in R, either one at a time or multiple together. These
elements are specified as indexes to the array, wherein the array values satisfying the conditions
are retained and rest removed. The comparison for removal is based on array values. Multiple
conditions can also be combined together to remove a range of elements. Another way to
remove elements is by using %in% operator wherein the set of element values belonging to the
TRUE values of the operator are displayed as result and the rest are removed.

# creating an array of length 9

m <- c(1, 2, 3, 4, 5, 6, 7, 8, 9)
print ("Original Array")
print (m)

# remove a single value element:3 from array

m <- m[m != 3]
print ("After 1st modification")
print (m)

Class in R
Class is the blueprint that helps to create an object and contains its member variable along with
the attributes. As discussed earlier in the previous section, there are two classes of R, S3, and
S4.
S3 Class
 S3 class is somewhat primitive in nature. It lacks a formal definition and object of this class
can be created simply by adding a class attribute to it.
 This simplicity accounts for the fact that it is widely used in R programming language. In
fact most of the R built-in classes are of this type.
Example 1: S3 class
# create a list with required components
s <- list(name = "John", age = 21, GPA = 3.5)
# name the class appropriately
class(s) <- "student"

S4 Class
 S4 class are an improvement over the S3 class. They have a formally defined structure
which helps in making object of the same class look more or less similar.
 Class components are properly defined using the setClass() function and objects are created
using the new() function.
Example 2: S4 class
< setClass("student", slots=list(name="character", age="numeric", GPA="numeric"))

Reference Class
 Reference class were introduced later, compared to the other two. It is more similar to the
object oriented programming we are used to seeing in other major programming languages.
 Reference classes are basically S4 classed with an environment added to it.
Example 3: Reference class
< setRefClass("student")

Factors
Introduction to Factors:
Factors in R Programming Language are data structures that are implemented to categorize the
data or represent categorical data and store it on multiple levels.

They can be stored as integers with a corresponding label to every unique integer. Though
factors may look similar to character vectors, they are integers and care must be taken while
using them as strings. The factor accepts only a restricted number of distinct values. For
example, a data field such as gender may contain values only from female, male.
Creating a Factor in R Programming Language
 The command used to create or modify a factor in R language is – factor() with a vector as
input.
The two steps to creating a factor are:
 Creating a vector
 Converting the vector created into a factor using function factor()

Example:

# Create a vector as input.

data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.

factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

Changing the Order of Levels

The order of the levels in a factor can be changed by applying the factor function again with
new order of the levels.

data <- c("East","West","East","North","North","East","West","West","West","East","North")

# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.

new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

Generating Factor Levels

We can generate factor levels by using the gl() function. It takes two integers as input which
indicates how many levels and how many times each level.
Syntax
gl(n, k, labels)
Following is the description of the parameters used −
 n is a integer giving the number of levels.
 k is a integer giving the number of replications.
 labels is a vector of labels for the resulting factor levels.

Example:
v <- gl(3, 4, labels = c("A", "B","C"))
print(v)

Accessing elements of a Factor in R

Like we access elements of a vector, the same way we access the elements of a factor. If gender
is a factor then gender[i] would mean accessing ith element in the factor.
Example:
gender <- factor(c("female", "male", "male", "female"))
gender[3]

Summarizing a Factor
The summary function in R returns the results of basic statistical calculations (minimum, 1st
quartile, median, mean, 3rd quartile, and maximum) for a numerical vector. The general way
to write the R summary function is summary(x, na.rm=FALSE/TRUE). Again, X refers to a
numerical vector, while na.rm=FALSE/TRUE specifies whether to remove empty values from
the calculation.
Example:
v <- gl(3, 4, labels = c("A", "B","C"))
print(v)
summary(v)

Level Ordering of Factors

Factors are data objects used to categorize data and store it as levels. They can store a string as
well as an integer. They represent columns as they have a limited number of unique values.
Factors in R can be created using factor() function. It takes a vector as input. c() function is
used to create a vector with explicitly provided values.
Example:
x < - c("Pen", "Pencil", "Brush", "Pen",
"Brush", "Brush", "Pencil", "Pencil")

print(x)
print(is.factor(x))

# Apply the factor function.

factor_x = factor(x)
levels(factor_x)

In the above code, x is a vector with 8 elements. To convert it to a factor the function factor()
is used. Here there are 8 factors and 3 levels. Levels are the unique elements in the data. Can
be found using levels() function.

Ordering Factor Levels

Ordered factors is an extension of factors. It arranges the levels in increasing order. We use
two functions: factor() along with argument ordered().

Syntax: factor(data, levels =c(“”), ordered =TRUE)

Parameter:
data: input vector with explicitly defined values.
levels(): Mention the list of levels in c function.
ordered: It is set true for enabling ordering.

Example:

size = c("small", "large", "large", "small","medium", "large", "medium", "medium")

# converting to factor
size_factor <- factor(size)
print(size_factor)

# ordering the levels

ordered.size <- factor(size, levels = c("small", "medium", "large"), ordered = TRUE)
print(ordered.size)
In the above code, size vector is created using c function. Then it is converted to a factor. And
for ordering factor() function is used along with the arguments described above. Thus the sizes
arranged in order.
 Data Frames
A data frame is a table or a two-dimensional array-like structure in which each column contains
values of one variable and each row contains one set of values from each column. Data frames
can also be interpreted as matrices where each column of a matrix can be of the different data
types.
Following are the characteristics of a data frame.

 The column names should be non-empty.

 The row names should be unique.
 The data stored in a data frame can be of numeric, factor or character type.
 Each column should contain same number of data items.

Creating Data Frame

friend.data <- data.frame(
friend_id = c(1:5),
friend_name = c("Sachin", "Sourav",
"Dravid", "Sehwag",
"Dhoni"),
)
# print the data frame
print(friend.data)

Output:
friend_id friend_name
1 1 Sachin
2 2 Sourav
3 3 Dravid
4 4 Sehwag
5 5 Dhoni

Summary of Data in Data Frame

The statistical summary and nature of the data can be obtained by
applying summary() function.
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
 emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),

start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",

"2015-03-27")),
stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))

When we execute the above code, it produces the following result −

emp_id emp_name salary start_date
Min. :1 Length:5 Min. :515.2 Min. :2012-01-01
1st Qu.:2 Class :character 1st Qu.:611.0 1st Qu.:2013-09-23
Median :3 Mode :character Median :623.3 Median :2014-05-11
Mean :3 Mean :664.4 Mean :2014-01-14
3rd Qu.:4 3rd Qu.:729.0 3rd Qu.:2014-11-15
Max. :5 Max. :843.2 Max. :2015-03-27

Extract Data from Data Frame

Extract specific column from a data frame using column name.
# Create the data frame.
emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),

start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11","2015-03-27")),
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

When we execute the above code, it produces the following result −

emp.data.emp_name emp.data.salary
1 Rick 623.30
2 Dan 515.20
3 Michelle 611.00
4 Ryan 729.00
5 Gary 843.25

Extract the first two rows and then all columns

result <- emp.data[1:2,]

Extract 3rd and 5th row with 2nd and 4th column
result <- emp.data[c(3,5),c(2,4)]

Expand Data Frame / Extending Data Frame

A data frame can be expanded by adding columns and rows.

Add Column
Just add the column vector using a new column name.

# Create the data frame.

emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),

start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")),

stringsAsFactors = FALSE
)

# Add the "dept" coulmn.

emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)
When we execute the above code, it produces the following result −
emp_id emp_name salary start_date dept
1 1 Rick 623.30 2012-01-01 IT
2 2 Dan 515.20 2013-09-23 Operations
3 3 Michelle 611.00 2014-11-15 IT
4 4 Ryan 729.00 2014-05-11 HR
5 5 Gary 843.25 2015-03-27 Finance

Add Row
To add more rows permanently to an existing data frame, we need to bring in the new rows in the
same structure as the existing data frame and use the rbind() function.

In the example below we create a data frame with new rows and merge it with the existing data frame
to create the final data frame.

# Create the first data frame.

emp.data <- data.frame(
emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),
start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-03-27")),
dept = c("IT","Operations","IT","HR","Finance"),
)

# Create the second data frame

emp.newdata <- data.frame(
emp_id = c (6:8),
emp_name = c("Rasmi","Pranab","Tusar"),
salary = c(578.0,722.5,632.8),
start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
dept = c("IT","Operations","Fianance"),
)

# Bind the two data frames.

emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

Remove Rows and Columns

Use the c() function to remove rows and columns in a Data Frame:
Example
Data_Frame <- data.frame (
Training = c("Strength", "Stamina", "Other"),
Pulse = c(100, 150, 120),
Duration = c(60, 30, 45)
)

# Remove the first row and column

Data_Frame_New <- Data_Frame[-c(1), -c(1)]

# Print the new data frame

Data_Frame_New

Pulse Duration
2 150 30
3 120 45

Create Subsets of a Data frame

subset() function in R Programming Language is used to create subsets of a Data frame. This
can also be used to drop columns from a data frame.

emp.data <- data.frame(

emp_id = c (1:5),
emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
salary = c(623.3,515.2,611.0,729.0,843.25),

start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11", "2015-

03-27")),
)
emp.data

subset(emp.data, emp_id == 3)

subset(emp.data, emp_id == c(1:3))

emp_id emp_name salary start_date

1 1 Rick 623.30 2012-01-01
2 2 Dan 515.20 2013-09-23
3 3 Michelle 611.00 2014-11-15
4 4 Ryan 729.00 2014-05-11
5 5 Gary 843.25 2015-03-27

emp_id emp_name salary start_date

3 3 Michelle 611 2014-11-15

emp_id emp_name salary start_date

1 1 Rick 623.3 2012-01-01
2 2 Dan 515.2 2013-09-23
3 3 Michelle 611.0 2014-11-15

Sorting Data
To sort a data frame in R, use the order( ) function. By default, sorting is ASCENDING.
Prepend the sorting variable by a minus sign to indicate DESCENDING order. Here are some
examples.
data = data.frame(
rollno = c(1, 5, 4, 2, 3),
subjects = c("java", "python", "php", "sql", "c"))

print(data)
print("sort the data in decreasing order based on subjects ")
print(data[order(data$subjects, decreasing = TRUE), ] )

print("sort the data in decreasing order based on rollno ")

print(data[order(data$rollno, decreasing = TRUE), ] )

Output:
 rollno subjects
1 1 java
2 5 python
3 4 php
4 2 sql
5 3 c
[1] "sort the data in decreasing order based on subjects "
rollno subjects
4 2 sql
2 5 python
3 4 php
1 1 java
5 3 c
[1] "sort the data in decreasing order based on rollno "
rollno subjects
2 5 python
3 4 php
5 3 c
4 2 sql
1 1 java

Lists
Lists are one-dimensional, heterogeneous data structures. The list can be a list of vectors, a
list of matrices, a list of characters and a list of functions, and so on.
A list is a vector but with heterogeneous data elements. A list in R is created with the use of
list() function. R allows accessing elements of a list with the use of the index value. In R, the
indexing of a list starts with 1 instead of 0 like other programming languages.

Creating a List
To create a List in R you need to use the function called “list()”. In other words, a list is a
generic vector containing other objects. To illustrate how a list looks, we take an example
here. We want to build a list of employees with the details. So for this, we want attributes
such as ID, employee name, and the number of employees.
empId = c(1, 2, 3, 4)

empName = c("Debi", "Sandeep", "Subham", "Shiba")

numberOfEmp = 4

empList = list(empId, empName, numberOfEmp)

print(empList)

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

Accessing components of a list

We can access components of a list in two ways.

Access components by names: All the components of a list can be named and we can use
those names to access the components of the list using the dollar command.

empId = c(1, 2, 3, 4)
empName = c("Debi", "Sandeep", "Subham", "Shiba")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
print(empList)

# Accessing components by names

cat("Accessing name components using $ command\n")
print(empList$Names)
Access components by indices: We can also access the components of the list using indices.
To access the top-level components of a list we have to use a double slicing operator “[[ ]]”
which is two square brackets and if we want to access the lower or inner level components of
a list we have to use another square bracket “[ ]” along with the double slicing operator “[[ ]]“.
empId = c(1, 2, 3, 4)
empName = c("Debi", "Sandeep", "Subham", "Shiba")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
print(empList)

# Accessing a top level components by indices

cat("Accessing name components using indices\n")
print(empList[[2]])

# Accessing a inner level components by indices

cat("Accessing Sandeep from name using indices\n")
print(empList[[2]][2])

# Accessing another inner level components by indices

cat("Accessing 4 from ID using indices\n")
print(empList[[1]][4])

Modifying components of a list

A list can also be modified by accessing the components and replacing them with the ones
which you want.
empId = c(1, 2, 3, 4)
empName = c("Debi", "Sandeep", "Subham", "Shiba")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
cat("Before modifying the list\n")
print(empList)

# Modifying the top-level component

empList$`Total Staff` = 5

# Modifying inner level component

empList[[1]][5] = 5
empList[[2]][5] = "Kamala"

cat("After modified the list\n")

print(empList)

Merging list
We can merge the list by placing all the lists into a single list.

lst1 <- list(1,2,3)

lst2 <- list("Sun","Mon","Tue")

# Merge the two lists.

new_list <- c(lst1,lst2)

# Print the merged list.

print(new_list)

Deleting components of a list

To delete components of a list, first of all, we need to access those components and then
insert a negative sign before those components. It indicates that we had to delete that
component.
empId = c(1, 2, 3, 4)
empName = c("Debi", "Sandeep", "Subham", "Shiba")
numberOfEmp = 4
empList = list(
"ID" = empId,
"Names" = empName,
"Total Staff" = numberOfEmp
)
cat("Before deletion the list is\n")
print(empList)

# Deleting a top level components

cat("After Deleting Total staff components\n")
print(empList[-3])

# Deleting a inner level components

cat("After Deleting sandeep from name\n")
print(empList[[2]][-2])

Converting List to Vector

Here we are going to convert the list to vector, for this we will create a list first and then
unlist the list into the vector.
# Create lists.
lst <- list(1:5)
print(lst)

# Convert the lists to vectors.

vec <- unlist(lst)

print(vec)
 Unit-4
Conditionals and control flow
R - 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
Following table shows the arithmetic operators supported by R language. The operators act on
each element of the vector.

Operator Description Example

+ Adds two vectors

v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v+t)
it produces the following result −
[1] 10.0 8.5 10.0

− Subtracts second vector from the first v <- c( 2,5.5,6)

t <- c(8, 3, 4)
print(v-t)
it produces the following result −
[1] -6.0 2.5 2.0

* Multiplies both vectors v <- c( 2,5.5,6)

t <- c(8, 3, 4)
print(v*t)
it produces the following result −
 [1] 16.0 16.5 24.0

/ Divide the first vector with the second v <- c( 2,5.5,6)

t <- c(8, 3, 4)
print(v/t)
When we execute the above code, it
produces the following result −
[1] 0.250000 1.833333 1.500000

%% Give the remainder of the first vector v <- c( 2,5.5,6)

with the second t <- c(8, 3, 4)
print(v%%t)
it produces the following result −
[1] 2.0 2.5 2.0

%/% The result of division of first vector v <- c( 2,5.5,6)

with second (quotient) t <- c(8, 3, 4)
print(v%/%t)
it produces the following result −
[1] 0 1 1

^ The first vector raised to the exponent v <- c( 2,5.5,6)

of second vector t <- c(8, 3, 4)
print(v^t)
it produces the following result −
[1] 256.000 166.375 1296.000

Relational Operators
Following table shows the relational operators supported by R language. 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 Description Example

> v <- c(2,5.5,6,9)

Checks if each element of the first vector is t <- c(8,2.5,14,9)
greater than the corresponding element of print(v>t)
the second vector. it produces the following result −
[1] FALSE TRUE FALSE FALSE
 < v <- c(2,5.5,6,9)
Checks if each element of the first vector is t <- c(8,2.5,14,9)
less than the corresponding element of the print(v < t)
second vector. it produces the following result −
[1] TRUE FALSE TRUE FALSE

== v <- c(2,5.5,6,9)
Checks if each element of the first vector is t <- c(8,2.5,14,9)
equal to the corresponding element of the print(v == t)
second vector. it produces the following result −
[1] FALSE FALSE FALSE TRUE

<= v <- c(2,5.5,6,9)

Checks if each element of the first vector is t <- c(8,2.5,14,9)
less than or equal to the corresponding print(v<=t)
element of the second vector. it produces the following result −
[1] TRUE FALSE TRUE TRUE

>= v <- c(2,5.5,6,9)

Checks if each element of the first vector is t <- c(8,2.5,14,9)
greater than or equal to the corresponding print(v>=t)
element of the second vector. it produces the following result −
[1] FALSE TRUE FALSE TRUE

!= v <- c(2,5.5,6,9)
Checks if each element of the first vector is t <- c(8,2.5,14,9)
unequal to the corresponding element of the print(v!=t)
second vector. it produces the following result −
[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 Description Example

 & It is called Element-wise Logical AND v <- c(3,1,TRUE,2+3i)
operator. It combines each element of the t <- c(4,1,FALSE,2+3i)
first vector with the corresponding element print(v&t)
of the second vector and gives a output it produces the following result −
TRUE if both the elements are TRUE.
[1] TRUE TRUE FALSE TRUE

| It is called Element-wise Logical OR v <- c(3,0,TRUE,2+2i)

operator. It combines each element of the t <- c(4,0,FALSE,2+3i)
first vector with the corresponding element print(v|t)
of the second vector and gives a output it produces the following result −
TRUE if one the elements is TRUE.
[1] TRUE FALSE TRUE TRUE

! v <- c(3,0,TRUE,2+2i)
It is called Logical NOT operator. Takes print(!v)
each element of the vector and gives the
opposite logical value. it produces the following result −
[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 Description Example

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

Called Logical AND operator. Takes first t <- c(1,3,TRUE,2+3i)
element of both the vectors and gives the print(v&&t)
TRUE only if both are TRUE. it produces the following result −
[1] TRUE

|| v <- c(0,0,TRUE,2+2i)
Called Logical OR operator. Takes first t <- c(0,3,TRUE,2+3i)
element of both the vectors and gives the print(v||t)
TRUE if one of them is TRUE. it produces the following result −
[1] FALSE
Assignment Operators
These operators are used to assign values to vectors.

Operator Description Example

Called Left Assignment v1 <- c(3,1,TRUE,2+3i)

<−
v2 <<- c(3,1,TRUE,2+3i)
 or v3 = c(3,1,TRUE,2+3i)
print(v1)
=
print(v2)
or print(v3)
<<− it produces the following result −
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

Called Right Assignment c(3,1,TRUE,2+3i) -> v1

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

->> it produces the following result −

[1] 3+0i 1+0i 1+0i 2+3i
[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 Description Example

: Colon v <- 2:8

operator. It print(v)
creates the
series of it produces the following result −
numbers in [1] 2 3 4 5 6 7 8
sequence
for a vector.

%in% v1 <- 8
This
v2 <- 12
operator is
t <- 1:10
used to print(v1 %in% t)
identify if print(v2 %in% t)
an element
belongs to a it produces the following result −
vector. [1] TRUE
[1] FALSE
 %*% This M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
operator is t = M %*% t(M)
used to print(t)
multiply a
it produces the following result −
matrix with
its [,1] [,2]
transpose. [1,] 65 82
[2,] 82 117

R - Decision making / Conditional statement

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.
Following is the general form of a typical decision making structure found in most of the
programming languages −

R provides the following types of decision making statements. Click the following links to
check their detail.

Sr.No. Statement & Description

1 if statement
An if statement consists of a Boolean expression followed by one or more statements.
 2 if...else statement
An if statement can be followed by an optional else statement, which executes when the
Boolean expression is false.

3 switch statement
A switch statement allows a variable to be tested for equality against a list of values.

R - If Statement
An if statement consists of a Boolean expression followed by one or more statements.
Syntax
The basic syntax for creating an if statement in R is −
if(boolean_expression) {
// statement(s) will execute if the boolean expression is true.
}
If the Boolean expression evaluates to be true, then the block of code inside the if statement
will be executed. If Boolean expression evaluates to be false, then the first set of code after the
end of the if statement (after the closing curly brace) will be executed.
Flow Diagram

Example
x <- 30L
if(is.integer(x)) {
print("X is an Integer")
}
When the above code is compiled and executed, it produces the following result −
[1] "X is an Integer"

R - If...Else Statement
An if statement can be followed by an optional else statement which executes when the boolean
expression is false.
Syntax
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.
}
If the Boolean expression evaluates to be true, then the if block of code will be executed,
otherwise else block of code will be executed.
Flow Diagram

Example
x <- c("what","is","truth")

if("Truth" %in% x) {
print("Truth is found")
} else {
print("Truth is not found")
}
When the above code is compiled and executed, it produces the following result −
[1] "Truth is not found"
Here "Truth" and "truth" are two different strings.
The if...else if...else Statement
An if statement can be followed by an optional else if...else statement, which is very useful to
test various conditions using single if...else if statement.
When using if, else if, else statements there are few points to keep in mind.
 An if can have zero or one else and it must come after any else if's.
 An if can have zero to many else if's and they must come before the else.
 Once an else if succeeds, none of the remaining else if's or else's will be tested.
Syntax
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.
}
Example
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")
}
When the above code is compiled and executed, it produces the following result −
[1] "truth is found the second time"

Nested If Statements

You can also have if statements inside if statements, this is called nested if statements.

Example
x <- 41

if (x > 10) {
print("Above ten")
if (x > 20) {
print("and also above 20!")
} else {
 print("but not above 20.")
}
} else {
print("below 10.")
}
AND

The & symbol (and) is a logical operator, and is used to combine conditional statements:

Example

Test if a is greater than b, AND if c is greater than a:

a <- 200
b <- 33
c <- 500

if (a > b & c > a){

print("Both conditions are true")
}
OR

The | symbol (or) is a logical operator, and is used to combine conditional statements:

Example

Test if a is greater than b, or if c is greater than a:

a <- 200
b <- 33
c <- 500

if (a > b | a > c){

print("At least one of the conditions is true")
}

R - 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.
Syntax
The basic syntax for creating a switch statement in R is −
switch(expression, case1, case2, case3....)
The following rules apply to a switch statement −
  If the value of expression is not a character string it is coerced to integer.
 You can have any number of case statements within a switch.
 If the value of the integer is between 1 and nargs()−1 (The max number of
arguments)then the corresponding element of case condition is evaluated and the result
returned.
 If expression evaluates to a character string then that string is matched (exactly) to the
names of the elements.
 If there is more than one match, the first matching element is returned.
 No Default argument is available.
 In the case of no match, if there is a unnamed element of ... its value is returned.
Flow Diagram

Example
x <- switch(
3,
"first",
"second",
"third",
"fourth"
)
print(x)
When the above code is compiled and executed, it produces the following result −
[1] "third"

Example 2:

# Following is val1 simple R program

# to demonstrate syntax of switch.

# Mathematical calculation

val1 = 6
val2 = 7
val3 = "s"
result = switch(
val3,
"a"= cat("Addition =", val1 + val2),
"d"= cat("Subtraction =", val1 - val2),
"r"= cat("Division = ", val1 / val2),
"s"= cat("Multiplication =", val1 * val2),
"m"= cat("Modulus =", val1 %% val2),
"p"= cat("Power =", val1 ^ val2)
)

print(result)

Iterative Programming in R
R - Loops

Introduction:
There may be a situation when you need to execute a block of code several number
of times. In general, statements are executed sequentially. The first statement in a
function is executed first, followed by the second, and so on.
Programming languages provide various control structures that allow for more
complicated execution paths.
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 −

R programming language provides the following kinds of loop to handle looping

requirements. Click the following links to check their detail.

Sr.No. Loop Type & Description

1 repeat loop
Executes a sequence of statements multiple times and abbreviates the code that
manages the loop variable.

2 while loop
 Repeats a statement or group of statements while a given condition is true. It
tests the condition before executing the loop body.

3 for loop
Like a while statement, except that it tests the condition at the end of the loop
body.

R - 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.

Syntax
The basic syntax for creating a for loop statement in R is −
for (value in vector) {
statements
}
Flow Diagram

R’s for loops are particularly flexible in that they are not limited to integers, or even
numbers in the input. We can pass character vectors, logical vectors, lists or
expressions.
Example
v <- LETTERS[1:4]
for ( i in v) {
print(i)
}
When the above code is compiled and executed, it produces the following result −
[1] "A"
[1] "B"
[1] "C"
[1] "D"

Example
for (x in 1:10) {
print(x)
}

Example 2: Program to display days of a week.

week < - c('Sunday',

'Monday',

'Tuesday',

'Wednesday',

'Thursday',

'Friday',

'Saturday')

for (day in week)

{ print(day)

R - While Loop
The While loop executes the same code again and again until a stop condition is met.
Syntax
The basic syntax for creating a while loop in R is −
while (test_expression) {
statement
}
Flow Diagram

Here key point of the while loop is that the loop might not ever run. When the condition
is tested and the result is false, the loop body will be skipped and the first statement
after the while loop will be executed.
Example1

val = 1

while (val <= 5)

{
print(val)
val = val + 1
}

Example2
n<-5
factorial < - 1
i<-1
while (i <= n)
{
factorial = factorial * i
i=i+1
}
print(factorial)
 R - Repeat Loop

It is a simple loop that will run the same statement or a group of statements
repeatedly until the stop condition has been encountered. Repeat loop does
not have any condition to terminate the loop, a programmer must specifically
place a condition within the loop’s body and use the declaration of a break
statement to terminate this loop. If no condition is present in the body of the
repeat loop then it will iterate infinitely.

Syntax
The basic syntax for creating a repeat loop in R is −
repeat
{
statement

if( condition )
{
break
}
}
Flow Diagram

Example1
val = 1

repeat
{
 print(val)
val = val + 1

if(val > 5)
{
break
}
}

Example 2:

i<-0

repeat
{
print("Geeks 4 geeks!")

i=i+1

if (i == 5)
{
break
}
}

Loop Control Statements/ Jump 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.
R supports the following control statements. Click the following links to check their
detail.

Sr.No. Control Statement & Description

1 break statement
Terminates the loop statement and transfers execution to the statement
immediately following the loop.

2 Next statement
The next statement simulates the behavior of R switch.

R - 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

Syntax
The basic syntax for creating a break statement in R is −break
Flow Diagram

Example
for (val in 1: 5)
{
# checking condition
if (val == 3)
{
# using break keyword
break
}

# displaying items in the sequence

print(val)
}

R - 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.
Syntax
The basic syntax for creating a next statement in R is −next
Flow Diagram

Example
for (val in 1: 5)
{
# checking condition
if (val == 3)
{
# using next keyword
next
}

# displaying items in the sequence

print(val)
}

Loop over a list

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.
For Loop in R Example 1: We iterate over all the elements of a vector and print the current
value.

# Create fruit vector

fruit <- c('Apple', 'Orange', 'Passion fruit', 'Banana')
# Create the for statement
for ( i in fruit){
print(i)
}

R - Functions
Functions are useful when you want to perform a certain task multiple times. A function accepts
input arguments and produces the output by executing valid R commands that are inside the
function. In R Programming Language when you are creating a function the function name and
the file in which you are creating the function need not be the same and you can have one or
more function definitions in a single R file.

Types of function in R Language

Built-in Function: Built function R is sqrt(), mean(), max(), these function are directly call in
the program by users.

User-defined Function: R language allow us to write our own function.

Functions in R Language
Functions are created in R by using the command function(). The general structure of the
function file is as follows:
Built-in Function in R Programming Language
Here we will use built-in function like sum(), max() and min().
print(sum(4:6))

# Find max of numbers 4 and 6.

print(max(4:6))

# Find min of numbers 4 and 6.

print(min(4:6))

User-defined Functions in R Programming Language

R provides built-in functions like print(), cat(), etc. but we can also create our own functions.
These functions are called user-defined functions.
evenOdd = function(x){
if(x %% 2 == 0)
return("even")
else
return("odd")
}

print(evenOdd(4))
print(evenOdd(3))

Single Input Single Output

Now create a function in R that will take a single input and gives us a single output.
areaOfCircle = function(radius){
area = pi*radius^2
return(area)
}

print(areaOfCircle(2))

Multiple Input Multiple Output

Now create a function in R Language that will take multiple inputs and gives us multiple
outputs using a list.
The functions in R Language takes multiple input objects but returned only one object as
output, this is, however, not a limitation because you can create lists of all the outputs which
you want to create and once the list is created you can access them into the elements of the
list and get the answers which you want.

Rectangle = function(length, width){

area = length * width
perimeter = 2 * (length + width)

# create an object called result which is

# a list of area and perimeter
result = list("Area" = area, "Perimeter" = perimeter)
return(result)
}

resultList = Rectangle(2, 3)
print(resultList["Area"])
print(resultList["Perimeter"])

Inline Functions in R Programming Language

Sometimes creating an R script file, loading it, executing it is a lot of work when you want
to just create a very small function. So, what we can do in this kind of situation is an inline
function.
To create an inline function you have to use the function command with the argument x and
then the expression of the function.
f = function(x) x*100

print(f(4))

Passing arguments to Functions in R Programming Language

There are several ways you can pass the arguments to the function:
 Case 1: Generally in R, the arguments are passed to the function in the same order as in
the function definition.
 Case 2: If you do not want to follow any order what you can do is you can pass the
arguments using the names of the arguments in any order.
 Case 3: If the arguments are not passed the default values are used to execute the
function.

Rectangle = function(length=5, width=4){

area = length * width
return(area)
}

# Case 1:
print(Rectangle(2, 3))
# Case 2:
print(Rectangle(width = 8, length = 4))

# Case 3:
print(Rectangle())

Lazy evaluations of Functions in R Programming Language

In R the functions are executed in a lazy fashion. When we say lazy what it means is if
some arguments are missing the function is still executed as long as the execution does not
involve those arguments.

Example1:
Cal= function(a,b,c){
v = a*b
return(v)
}

print(Cal(5, 10))

Example2:
Cal= function(a,b,c){
v = a*b*c
return(v)
}

print(Cal(5, 10))

Function Arguments in R Programming

Arguments are the parameters provided to a function to perform operations in a programming
language. In R programming, we can use as many arguments as we want and are separated
by a comma. There is no limit on the number of arguments in a function in R. In this article,
we’ll discuss different ways of adding arguments in a function in R programming.

Adding Arguments in R
We can pass an argument to a function while calling the function by simply giving the value
as an argument inside the parenthesis. Below is an implementation of a function with a single
argument.
divisbleBy5 <- function(n){
if(n %% 5 == 0)
{
return("number is divisible by 5")
}
else
{
return("number is not divisible by 5")
}
}
# Function call
divisbleBy5(100)
Adding Multiple Arguments in R
A function in R programming can have multiple arguments too. Below is an
implementation of a function with multiple arguments.
divisible <- function(a, b){
if(a %% b == 0)
{
return(paste(a, "is divisible by", b))
}
else
{
return(paste(a, "is not divisible by", b))
}
}

# Function call
divisible(7, 3)

Adding Default Value in R

Default value in a function is a value that is not required to specify each time the function is
called. If the value is passed by the user, then the user-defined value is used by the function
otherwise, the default value is used. Below is an implementation of function with default
value.
divisible <- function(a, b = 3){
if(a %% b == 0)
{
return(paste(a, "is divisible by", b))
}
else
{
return(paste(a, "is not divisible by", b))
}
}

# Function call
divisible(10, 5)
divisible(12)

Dots Argument
Dots argument (…) is also known as ellipsis which allows the function to take an undefined
number of arguments. It allows the function to take an arbitrary number of arguments.
Below is an example of a function with an arbitrary number of arguments.
fun <- function(n, ...){
l <- list(n, ...)
paste(l, collapse = " ")
}
# Function call
fun(5, 1L, 6i, 15.2, TRUE)

Recursive Functions in R Programming

The recursive function uses the concept of recursion to perform iterative tasks they call
themselves, again and again, which acts as a loop. These kinds of functions need a stopping
condition so that they can stop looping continuously.
Recursive functions call themselves. They break down the problem into smaller components.
The function() calls itself within the original function() on each of the smaller components.
After this, the results will be put together to solve the original problem.
Example1:
fac <- function(x){
if(x==0 || x==1)
{
return(1)
}
else
{
return(x*fac(x-1))
}
}

fac(3)

Nested Functions

There are two ways to create a nested function:

 Call a function within another function.

 Write a function within a function.

 Call a function within another function.

Example

Call a function within another function:

Nested_function <- function(x, y) {

a <- x + y
return(a)
}

Nested_function(Nested_function(2,2), Nested_function(3,3))
  Write a function within a function.

Example

Write a function within a function:

Outer_func <- function(x) {

Inner_func <- function(y) {
a <- x + y
return(a)
}
return (Inner_func)
}
output <- Outer_func(3) # To call the Outer_func
output(5)

Loading an R package

Packages
Packages are collections of R functions, data, and compiled code in a well-defined format. The
directory where packages are stored is called the library. R comes with a standard set of
packages. Others are available for download and installation. Once installed, they have to be
loaded into the session to be used.

.libPaths() # get library location

library() # see all packages installed

search() # see packages currently loaded

Adding Packages
You can expand the types of analyses you do be adding other packages. A complete list of
contributed packages is available from CRAN.

Follow these steps:

1. Download and install a package (you only need to do this once).

2. To use the package, invoke the library(package) command to load it into the current session.
(You need to do this once in each session, unless you customize your environment to
automatically load it each time.)
On MS Windows:
1. Choose Install Packages from the Packages menu.
2. Select a CRAN Mirror. (e.g. Norway)
3. Select a package. (e.g. boot)
4. Then use the library(package) function to load it for use. (e.g. library(boot))

Load an R Package

There are basically two extremely important functions when it comes down to R packages:

 install.packages(), which as you can expect, installs a given package.

 library() which loads packages, i.e. attaches them to the search list on your R
workspace.

To install packages, you need administrator privileges. This means that install.packages() will
thus not work in the DataCamp interface. However, almost all CRAN packages are installed
on our servers. You can load them with library().

In this exercise, you'll be learning how to load the ggplot2 package, a powerful package for
data visualization. You'll use it to create a plot of two variables of the mtcars data frame. The
data has already been prepared for you in the workspace.

Before starting, execute the following commands in the console:

 search(), to look at the currently attached packages and

 qplot(mtcars$wt, mtcars$hp), to build a plot of two variables of the mtcars data frame.

Mathematical Functions in R

R provides the various mathematical functions to perform the mathematical calculation. These
mathematical functions are very helpful to find absolute value, square value and much more
calculations. In R, there are the following functions which are used:

S. No Function Description Example

1. abs(x) It returns the absolute value of input x. x<- -4

print(abs(x))
Output
[1] 4
2. sqrt(x) It returns the square root of input x. x<- 4
print(sqrt(x))
Output
[1] 2
3. ceiling(x) It returns the smallest integer which is larger than or x<- 4.5
equal to x. print(ceiling(x))
Output
[1] 5
4. floor(x) It returns the largest integer, which is smaller than or x<- 2.5
equal to x. print(floor(x))
Output
[1] 2
5. trunc(x) It returns the truncate value of input x. x<- c(1.2,2.5,8.1)
print(trunc(x))
Output
[1] 1 2 8
6. round(x, It returns round value of input x. x<- -4
digits=n) print(abs(x))
Output
4
7. cos(x), It returns cos(x), sin(x) value of input x. x<- 4
sin(x), print(cos(x))
tan(x) print(sin(x))
print(tan(x))
Output
[1] -06536436
[2] -0.7568025
[3] 1.157821
8. log(x) It returns natural logarithm of input x. x<- 4
print(log(x))
Output
[1] 1.386294
9. log10(x) It returns common logarithm of input x. x<- 4
print(log10(x))
Output
[1] 0.60206
10. exp(x) It returns exponent. x<- 4
print(exp(x))
Output
[1] 54.59815
 Unit-5
Data Reduction
Imagine that you have selected data from the AllElectronics data warehouse for analysis. The
data set will likely be huge! Complex data analysis and mining on huge amounts of data can
take a long time, making such analysis impractical or infeasible.
Data reduction techniques can be applied to obtain a reduced representation of the data set that
is much smaller in volume, yet closely maintains the integrity of the original data. That is,
mining on the reduced data set should be more efficient yet produce the same (or almost the
same) analytical results.

Overview of Data Reduction Strategies

Data reduction strategies include dimensionality reduction, numerosity reduction, and data
compression.

Dimensionality reduction is the process of reducing the number of random variables or

attributes under consideration.
 Dimensionality reduction methods include wavelet transforms and principal
components analysis, which transform or project the original data onto a smaller space.
 Attribute subset selection is a method of dimensionality reduction in which irrelevant,
weakly relevant, or redundant attributes or dimensions are detected and removed.

Numerosity reduction techniques replace the original data volume by alternative, smaller
forms of data representation.
 These techniques may be parametric or nonparametric.
 For parametric methods, a model is used to estimate the data, so that typically only the
data parameters need to be stored, instead of the actual data. (Outliers may also be
stored.) Regression and log-linear models are examples.
 Nonparametric methods for storing reduced representations of the data include
histograms, clustering, sampling, and data cube aggregation.

In data compression, transformations are applied so as to obtain a reduced or “compressed”

representation of the original data. If the original data can be reconstructed from the
compressed data without any information loss, the data reduction is called lossless.
 If, instead, we can reconstruct only an approximation of the original data, then the data
reduction is called lossy.
 There are several lossless algorithms for string compression; however, they typically
allow only limited data manipulation.
 Dimensionality reduction and numerosity reduction techniques can also be considered
forms of data compression.
 There are many other ways of organizing methods of data reduction. The computational
time spent on data reduction should not outweigh or “erase” the time saved by mining
on a reduced data set size.
Wavelet Transforms
The discrete wavelet transform (DWT) is a linear signal processing technique that, when
applied to a data vector X, transforms it to a numerically different vector, X’, of wavelet
coefficients.
 The two vectors are of the same length. When applying this technique to data reduction,
we consider each tuple as an n-dimensional data vector, that is, X =(.x1,x2, .,., ,xn),
depicting n measurements made on the tuple from n database attributes.
 “How can this technique be useful for data reduction if the wavelet transformed data
are of the same length as the original data?” The usefulness lies in the fact that the
wavelet transformed data can be truncated. A compressed approximation of the data
can be retained by storing only a small fraction of the strongest of the wavelet
coefficients.

 The technique also works to remove noise without smoothing out the main features of
the data, making it effective for data cleaning as well. Given a set of coefficients, an
approximation of the original data can be constructed by applying the inverse of the
DWT used.

 The DWT is closely related to the discrete Fourier transform (DFT), a signal
processing technique involving sines and cosines. In general, however, the DWT
achieves better lossy compression.
 Unlike the DFT, wavelets are quite localized in space, contributing to the conservation
of local detail.

There is only one DFT, yet there are several families of DWTs. Figure 3.4 shows some wavelet
families. Popular wavelet transforms include the Haar-2, Daubechies-4, and Daubechies-6. The
general procedure for applying a discrete wavelet transform uses a hierarchical pyramid
algorithm that halves the data at each iteration, resulting in fast computational speed.

The method is as follows:

1. The length, L, of the input data vector must be an integer power of 2. This condition can be
met by padding the data vector with zeros as necessary (L >=n).
2. Each transform involves applying two functions. The first applies some data smoothing, such
as a sum or weighted average. The second performs a weighted difference, which acts to bring
out the detailed features of the data.
3. The two functions are applied to pairs of data points in X, that is, to all pairs of measurements
.x2i ,x2i+1. This results in two data sets of length L=2. In general, these represent a smoothed
or low-frequency version of the input data and the high frequency content of it, respectively.
4. The two functions are recursively applied to the data sets obtained in the previous loop, until
the resulting data sets obtained are of length 2. 5. Selected values from the data sets obtained
in the previous iterations are designated the wavelet coefficients of the transformed data.
  Equivalently, a matrix multiplication can be applied to the input data in order to obtain
the wavelet coefficients, where the matrix used depends on the given DWT.
 The matrix must be orthonormal, meaning that the columns are unit vectors and are
mutually orthogonal, so that the matrix inverse is just its transpose. By factoring the
matrix used into a product of a few sparse matrices, the resulting “fast DWT” algorithm
has a complexity of O(n) for an input vector of length n.

 Wavelet transforms can be applied to multidimensional data such as a data cube. This
is done by first applying the transform to the first dimension, then to the second, and so
on.
 Lossy compression by wavelets is reportedly better than JPEG compression, the current
commercial standard.
 Wavelet transforms have many real world applications, including the compression of
fingerprint images, computer vision, analysis of time-series data, and data cleaning.

Principal Components Analysis

Principal components analysis (PCA; also called the K-L, method) searches for k n-
dimensional orthogonal vectors that can best be used to represent the data, where k <= n.
The original data are thus projected onto a much smaller space, resulting in dimensionality
reduction.

The basic procedure is as follows:

1. The input data are normalized, so that each attribute falls within the same range. This step
helps ensure that attributes with large domains will not dominate attributes with smaller
domains.
2. PCA computes k orthonormal vectors that provide a basis for the normalized input data.
3. The principal components are sorted in order of decreasing “significance” or strength.
4. Because the components are sorted in decreasing order of “significance,” the data size can
be reduced by eliminating the weaker components, that is, those with low variance. Using the
strongest principal components, it should be possible to reconstruct a good approximation of
the original data.
Attribute Subset Selection
Data sets for analysis may contain hundreds of attributes, many of which may be irrelevant to
the mining task or redundant. For example, if the task is to classify customers based on whether
or not they are likely to purchase a popular new CD at AllElectronics when notified of a sale,
attributes such as the customer’s telephone number are likely to be irrelevant, unlike attributes
such as age or music taste.
Although it may be possible for a domain expert to pick out some of the useful attributes, this
can be a difficult and time consuming task, especially when the data’s behavior is not well
known. (Hence, a reason behind its analysis!) Leaving out relevant attributes or keeping
irrelevant attributes may be detrimental, causing confusion for the mining algorithm employed.
This can result in discovered patterns of poor quality. In addition, the added volume of
irrelevant or redundant attributes can slow down the mining process.

Attribute subset selection reduces the data set size by removing irrelevant or redundant
attributes (or dimensions). The goal of attribute subset selection is to find a minimum set of
attributes such that the resulting probability distribution of the data classes is as close as
possible to the original distribution obtained using all attributes. Mining on a reduced set of
attributes has an additional benefit: It reduces the number of attributes appearing in the
discovered patterns, helping to make the patterns easier to understand.

Therefore, heuristic methods that explore a reduced search space are commonly used for
attribute subset selection. These methods are typically greedy in that, while searching through
attribute space, they always make what looks to be the best choice at the time. Their strategy
is to make a locally optimal choice in the hope that this will lead to a globally optimal solution.
Such greedy methods are effective in practice and may come close to estimating an optimal
solution.
The “best” (and “worst”) attributes are typically determined using tests of statistical
significance, which assume that the attributes are independent of one another. Many other
attribute evaluation measures can be used such as the information gain measure used in
building decision trees for classification.5
Basic heuristic methods of attribute subset selection include the techniques that follow, some
of which are illustrated in Figure 3.6.
1. Stepwise forward selection: The procedure starts with an empty set of attributes as the
reduced set. The best of the original attributes is determined and added to the reduced set. At
each subsequent iteration or step, the best of the remaining original attributes is added to the
set.
2. Stepwise backward elimination: The procedure starts with the full set of attributes. At each
step, it removes the worst attribute remaining in the set.
3. Combination of forward selection and backward elimination: The stepwise forward
selection and backward elimination methods can be combined so that, at each step, the
procedure selects the best attribute and removes the worst from among the remaining attributes.
4. Decision tree induction: Decision tree algorithms (e.g., ID3, C4.5, and CART) were
originally intended for classification. Decision tree induction constructs a flowchart like
structure where each internal (nonleaf) node denotes a test on an attribute, each branch
corresponds to an outcome of the test, and each external (leaf) node denotes a class prediction.
At each node, the algorithm chooses the “best” attribute to partition the data into individual
classes.
When decision tree induction is used for attribute subset selection, a tree is constructed from
the given data. All attributes that do not appear in the tree are assumed to be irrelevant. The set
of attributes appearing in the tree form the reduced subset of attributes.

Regression and Log-Linear Models: Parametric Data Reduction

Regression and log-linear models can be used to approximate the given data. In (simple) linear
regression, the data are modeled to fit a straight line. For example, a random variable, y (called
a response variable), can be modeled as a linear function of another random variable, x (called
a predictor variable), with the equation
where the variance of y is assumed to be constant. In the context of data mining, x and y are
numeric database attributes. The coefficients, w and b (called regression coefficients), specify
the slope of the line and the y-intercept, respectively.

Multiple linear regression is an extension of (simple) linear regression, which allows a

response variable, y, to be modeled as a linear function of two or more predictor variables.

Log-linear models approximate discrete multidimensional probability distributions.

 Given a set of tuples in n dimensions (e.g., described by n attributes), we can consider
each tuple as a point in an n-dimensional space.
 Log-linear models can be used to estimate the probability of each point in a
multidimensional space for a set of discretized attributes, based on a smaller subset of
dimensional combinations.
 This allows a higher-dimensional data space to be constructed from lower-dimensional
spaces.

Histograms
Histograms use discarding to approximate data distributions and are a popular form of data
reduction. A histogram for an attribute, A, partitions the data distribution of A into disjoint
subsets, referred to as buckets or bins. If each bucket represents only a single attribute–
value/frequency pair, the buckets are called singleton buckets. Often, buckets instead represent
continuous ranges for the given attribute.
Clustering
 Clustering techniques consider data tuples as objects.
 They partition the objects into groups, or clusters, so that objects within a cluster are
“similar” to one another and “dissimilar” to objects in other clusters.
 Similarity is commonly defined in terms of how “close” the objects are in space, based
on a distance function.
 The “quality” of a cluster may be represented by its diameter, the maximum distance
between any two objects in the cluster.
 Centroid distance is an alternative measure of cluster quality and is defined as the
average distance of each cluster object from the cluster centroid.
 In data reduction, the cluster representations of the data are used to replace the actual
data.

Sampling
Sampling can be used as a data reduction technique because it allows a large data set to
be represented by a much smaller random data sample (or subset). Suppose that a large data
set, D, contains N tuples. Let’s look at the most common ways that we could sample D for data
reduction, as illustrated in Figure 3.9.

Simple random sample without replacement (SRSWOR) of size s: This is created by

drawing s of the N tuples from D (s < N), where the probability of drawing any tuple in D is
1=N, that is, all tuples are equally likely to be sampled.

Simple random sample with replacement (SRSWR) of size s: This is similar to SRSWOR,
except that each time a tuple is drawn from D, it is recorded and then replaced. That is, after a
tuple is drawn, it is placed back in D so that it may be drawn again.
Cluster sample: If the tuples in D are grouped into M mutually disjoint “clusters,” then an SRS
of s clusters can be obtained, where s < M. For example, tuples in a database are usually
retrieved a page at a time, so that each page can be considered a cluster. A reduced data
representation can be obtained by applying, say, SRSWOR to the pages, resulting in a cluster
sample of the tuples. Other clustering criteria conveying rich semantics can also be explored.
For example, in a spatial database, we may choose to define clusters geographically based on
how closely different areas are located.

Stratified sample: If D is divided intomutually disjoint parts called strata, a stratified sample
of D is generated by obtaining an SRS at each stratum. This helps ensure a representative
sample, especially when the data are skewed. For example, a stratified sample may be obtained
fromcustomer data, where a stratum is created for each customer age group. In this way, the
age group having the smallest number of customers will be sure to be represented

An advantage of sampling for data reduction is that the cost of obtaining a sample is
proportional to the size of the sample, s, as opposed to N, the data set size. Hence, sampling
complexity is potentially sublinear to the size of the data. Other data reduction techniques can
require at least one complete pass through D. For a fixed sample size, sampling complexity
increases only linearly as the number of data dimensions, n, increases, whereas techniques
using histograms, for example, increase exponentially in n.
When applied to data reduction, sampling is most commonly used to estimate the answer to an
aggregate query. It is possible (using the central limit theorem) to determine a sufficient sample
size for estimating a given function within a specified degree of error. This sample size, s, may
be extremely small in comparison to N. Sampling is a natural choice for the progressive
refinement of a reduced data set. Such a set can be further refined by simply increasing the
sample size.

Data Cube Aggregation

Imagine that you have collected the data for your analysis. These data consist of the
AllElectronics sales per quarter, for the years 2008 to 2010. You are, however, interested in the
annual sales (total per year), rather than the total per quarter. Thus, the data can be aggregated
so that the resulting data summarize the total sales per year instead of per quarter. This
aggregation is illustrated in Figure 3.10. The resulting data set is smaller in volume, without
loss of information necessary for the analysis task. Data cubes are discussed in detail in Chapter
4 on data warehousing and Chapter 5 on data cube technology. We briefly introduce some
concepts here. Data cubes store

Multi-dimensional aggregated information. For example, the above Figure shows a data
cube for multidimensional analysis of sales data with respect to annual sales per item type for
each AllElectronics branch. Each cell holds an aggregate data value, corresponding to the data
point in multidimensional space. (For readability, only some cell values are shown.) Concept
hierarchies may exist for each attribute, allowing the analysis of data at multiple abstraction
levels. For example, a hierarchy for branch could allow branches to be grouped into regions,
based on their address. Data cubes provide fast access to precomputed, summarized data,
thereby benefiting online analytical processing as well as data mining.

The cube created at the lowest abstraction level is referred to as the base cuboid. The
base cuboid should correspond to an individual entity of interest such as sales or customer. In
other words, the lowest level should be usable, or useful for the analysis. A cube at the highest
level of abstraction is the apex cuboid. For the sales data in Figure 3.11, the apex cuboid would
give one total—the total sales for all three years, for all item types, and for all branches. Data
cubes created for varying levels of abstraction are often referred to as cuboids, so that a data
cube may instead refer to a lattice of cuboids. Each higher abstraction level further reduces the
resulting data size. When replying to data mining requests, the smallest available cuboid
relevant to the given task should be used.

Data Visualization
Data visualization aims to communicate data clearly and effectively through graphical
representation. Data visualization has been used extensively in many applications—for
example, at work for reporting, managing business operations, and tracking progress of tasks.
More popularly, we can take advantage of visualization techniques to discover data
relationships that are otherwise not easily observable by looking at the raw data. Nowadays,
people also use data visualization to create fun and interesting graphics.

This section start with multidimensional data such as those stored in relational
databases. We discuss several representative approaches, including pixel-oriented techniques,
geometric projection techniques, icon-based techniques, and hierarchical and graph-based
techniques. We then discuss the visualization of complex data and relations.

Pixel-Oriented Visualization Techniques

A simple way to visualize the value of a dimension is to use a pixel where the color of
the pixel reflects the dimension’s value. For a data set of m dimensions, pixel-oriented
techniques create m windows on the screen, one for each dimension. The m dimension values
of a record are mapped tompixels at the corresponding positions in the windows.
The colors of the pixels reflect the corresponding values. Inside a window, the data
values are arranged in some global order shared by all windows. The global order may be
obtained by sorting all data records in a way that’s meaningful for the task at hand.
Pixel-oriented visualization. AllElectronics maintains a customer information table,
which consists of four dimensions: income, credit limit, transaction volume, and age. Can we
analyze the correlation between income and the other attributes by visualization? We can sort
all customers in income-ascending order, and use this order to lay out the customer data in the
four visualization windows, as shown in Figure 2.10. The pixel colors are chosen so that the
smaller the value, the lighter the shading. Using pixelbased visualization, we can easily observe
the following: credit limit increases as income increases; customers whose income is in the
middle range are more likely to purchase more from AllElectronics; there is no clear correlation
between income and age.
In pixel-oriented techniques, data records can also be ordered in a query-dependent
way. For example, given a point query, we can sort all records in descending order of similarity
to the point query.
Filling a window by laying out the data records in a linear way may not work well for
a wide window. The first pixel in a row is far away fromthe last pixel in the previous row,
though they are next to each other in the global order. Moreover, a pixel is next to the one
above it in the window, even though the two are not next to each other in the global order. To
solve this problem, we can lay out the data records in a space-filling curve to fill the windows.
A space-filling curve is a curve with a range that covers the entire n-dimensional unit
hypercube. Since the visualization windows are 2-D, we can use any 2-D space-filling curve.
Figure 2.11 shows some frequently used 2-D space-filling curves. Note that the
windows do not have to be rectangular. For example, the circle segment technique uses
windows in the shape of segments of a circle, as illustrated in Figure 2.12. This technique can
ease the comparison of dimensions because the dimension windows are located side by side
and form a circle.
Geometric Projection Visualization Techniques

A drawback of pixel-oriented visualization techniques is that they cannot help us much

in understanding the distribution of data in a multidimensional space. For example, they do not
show whether there is a dense area in a multidimensional subspace. Geometric projection
techniques help users find interesting projections of multidimensional data sets. The central
challenge the geometric projection techniques try to address is how to visualize a high-
dimensional space on a 2-D display.

A scatter plot displays 2-D data points using Cartesian coordinates. A third dimension
can be added using different colors or shapes to represent different data points. Figure 2.13
shows an example, where X and Y are two spatial attributes and the third dimension is
represented by different shapes. Through this visualization, we can see that points of types “+”
and “_” tend to be colocated.

A 3-D scatter plot uses three axes in a Cartesian coordinate system. If it also uses color,
it can display up to 4-D data points (Figure 2.14).
 For data sets with more than four dimensions, scatter plots are usually ineffective. The
scatter-plot matrix technique is a useful extension to the scatter plot. For an n dimensional
data set, a scatter-plot matrix is an n_n grid of 2-D scatter plots that provides a visualization of
each dimension with every other dimension. Figure 2.15 shows an example, which visualizes
the Iris data set. The data set consists of 450 samples from each of three species of Iris flowers.
There are five dimensions in the data set: length and width of sepal and petal, and species. The
scatter-plot matrix becomes less effective as the dimensionality increases. Another popular
technique, called parallel coordinates, can handle higher dimensionality. To visualize n-
dimensional data points, the parallel coordinates technique draws n equally spaced axes, one
for each dimension, parallel to one of the display axes.

A data record is represented by a polygonal line that intersects each axis at the point
corresponding to the associated dimension value.
 A major limitation of the parallel coordinates technique is that it cannot effectively
show a data set of many records. Even for a data set of several thousand records, visual clutter
and overlap often reduce the readability of the visualization and make the patterns hard to find.

Icon-Based Visualization Techniques

Icon-based visualization techniques use small icons to represent multidimensional data

values. We look at two popular icon-based techniques: Chernoff faces and stick figures.
Chernoff faces were introduced in 1973 by statistician Herman Chernoff. They display
multidimensional data of up to 18 variables (or dimensions) as a cartoon human face (Figure
2.17). Chernoff faces help reveal trends in the data. Components of the face, such as the eyes,
ears, mouth, and nose, represent values of the dimensions by their shape, size, placement, and
orientation.
For example, dimensions can be mapped to the following facial characteristics: eye
size, eye spacing, nose length, nose width, mouth curvature, mouth width, mouth openness,
pupil size, eyebrow slant, eye eccentricity, and head eccentricity. Chernoff faces make use of
the ability of the human mind to recognize small differences in facial characteristics and to
assimilate many facial characteristics at once.

Viewing large tables of data can be tedious. By condensing the data, Chernoff faces
make the data easier for users to digest. In this way, they facilitate visualization of regularities
and irregularities present in the data, although their power in relating multiple relationships is
limited. Another limitation is that specific data values are not shown.
Furthermore, facial features vary in perceived importance. This means that the
similarity of two faces (representing twomultidimensional data points) can vary depending on
the order in which dimensions are assigned to facial characteristics. Therefore, this mapping
should be carefully chosen. Eye size and eyebrow slant have been found to be important.
Asymmetrical Chernoff faces were proposed as an extension to the original technique.

Since a face has vertical symmetry (along the y-axis), the left and right side of a face
are identical, which wastes space. Asymmetrical Chernoff faces double the number of facial
characteristics, thus allowing up to 36 dimensions to be displayed. The stick figure
visualization technique maps multidimensional data to five-piece stick figures, where each
figure has four limbs and a body. Two dimensions are mapped to the display (x and y) axes
and the remaining dimensions are mapped to the angle and/or length of the limbs. Figure 2.18
shows census data, where age and income are mapped to the display axes, and the remaining
dimensions (gender, education, and so on) are mapped to stick figures. If the data items are
relatively dense with respect to the two display dimensions, the resulting visualization shows
texture patterns, reflecting data trends.

Hierarchical Visualization Techniques

The visualization techniques discussed so far focus on visualizing multiple dimensions

simultaneously. However, for a large data set of high dimensionality, it would be difficult to
visualize all dimensions at the same time. Hierarchical visualization techniques partition all
dimensions into subsets (i.e., subspaces). The subspaces are visualized in a hierarchical
manner. “Worlds-within-Worlds,” also known as n-Vision, is a representative hierarchical
visualization method. Suppose we want to visualize a 6-D data set, where the dimensions are
F,X1, . , . , . , X5.We want to observe how dimension F changes with respect to the other
dimensions.
We can first fix the values of dimensions X3,X4,X5 to some selected values, say, c3,
c4, c5.We can then visualize F,X1,X2 using a 3-D plot, called a world, as shown in Figure 2.19.
The position of the origin of the inner world is located at the point .c3, c4, c5/ in the outer
world, which is another 3-D plot using dimensions X3,X4,X5. A user can interactively change,
in the outer world, the location of the origin of the inner world. The user then views the resulting
changes of the inner world. Moreover, a user can vary the dimensions used in the inner world
and the outer world. Given more dimensions, more levels of worlds can be used, which is why
the method is called “worlds-within worlds.”
As another example of hierarchical visualization methods, tree-maps display
hierarchical data as a set of nested rectangles. For example, Figure 2.20 shows a tree-map
visualizing Google news stories. All news stories are organized into seven categories, each
shown in a large rectangle of a unique color. Within each category (i.e., each rectangle at the
top level), the news stories are further partitioned into smaller subcategories.

Visualizing Complex Data and Relations

In early days, visualization techniques were mainly for numeric data. Recently, more
and more non-numeric data, such as text and social networks, have become available.
Visualizing and analyzing such data attracts a lot of interest. There are many new visualization
techniques dedicated to these kinds of data.
 For example, many people on theWeb tag various objects such as pictures, blog entries,
and product reviews. A tag cloud is a visualization of statistics of user-generated tags. Often,
in a tag cloud, tags are listed alphabetically or in a user-preferred order. The importance of a
tag is indicated by font size or color. Figure 2.21 shows a tag cloud for visualizing the popular
tags used in aWeb site. Tag clouds are often used in two ways. First, in a tag cloud for a single
item, we can use the size of a tag to represent the number of times that the tag is applied to this
item by different users.
Second, when visualizing the tag statistics on multiple items, we can use the size of a
tag to represent the number of items that the tag has been applied to, that is, the popularity of
the tag. In addition to complex data, complex relations among data entries also raise challenges
for visualization. For example, Figure 2.22 uses a disease influence graph to visualize the
correlations between diseases. The nodes in the graph are diseases, and the size of each node
is proportional to the prevalence of the corresponding disease. Two nodes are linked by an edge
if the corresponding diseases have a strong correlation.
The width of an edge is proportional to the strength of the correlation pattern of the two
corresponding diseases.
In summary, visualization provides effective tools to explore data. We have introduced
several popular methods and the essential ideas behind them. There are many existing tools
and methods. Moreover, visualization can be used in data mining in various aspects. In addition
to visualizing data, visualization can be used to represent the data mining process, the patterns
obtained from a mining method, and user interaction with the data. Visual data mining is an
important research and development direction.