Data Analytics with

R
Semester 3
Course Code BDS306C

Module-1 Basics of R: 5 hours

Introducing R, Initiating R, Packages in R, Environments and Functions,
Flow Controls, Loops, Basic Data Types in R, Vectors
Chapter 1: 1.1 to 1.7 Chapter 2: 2.1,2.2
 Introducing R

• R is a Programming Language
• R also refers to the software that is used to run the R programs .
• Ross Ihaka and Robert Gentleman from University of Auckland created R language in 1990s.
• R language is based on the S language.
• S Language was developed at the Bell Laboratories in 1970s.
• S Language was developed by John Chambers.
• R Software is a GNU project-free (GNU is an operating system which is
100% free software, GNU stands for Gnu's Not Unix, and it is pronounced as “g-noo”) and
open source software.
• R (Language and Software) is developed by the R Core Team.
• R has evolved over the past 3 to 4 decades as its history originated from 1970s.
 One can write a new package in R if the existing package is not sufficient for the
individual’s use.
 R is a high-level scripting language which need not be compiled, but it is an interpreted
language.
 R is an imperative language(composed of step-by-step instructions) and still it supports
object-oriented programming.
 R is a free open source language that has cross platform compatibility.
 R is a most advanced statistical programming language and it can produce outstanding
graphical outputs.
 R is extremely flexible and comprehensive even for the beginners.
 R easily relates to other programming languages such as C, C++, Java, Python, Hadoop,
etc.
 R can handle huge data in flat files even in semi structured or in unstructured form.
 The R language allows the user to program loops to successively analyze several data sets.
 It is also possible to combine in single program different statistical functions to perform
more complex analyses.
 R displays the results of the analysis immediately and these results are stored in “objects”
so that further analysis can be done on them.
 The user can also extract a part of the result which is of interest to him.
 R is an interpreted language and not a compiled one. This means that all commands typed
on the keyboard are directly executed without need to build the complete program like in
C, C++ or Java.
 R’s syntax is very simple and intuitive.
 In R, a function is always written with parentheses, eg. ls().
 If only the name of the function is typed, R displays the content of the function.
 When R is running, variables, data, functions, results, etc. are stored in the active memory
of the computer in the form of objects which have a name.
 The user can do actions on these objects with operators and functions.
Installing R
 R is available in several forms, for Unix and Linux machines, or some pre-compiled
binaries for Windows, Linux and Macintosh.
 The files needed to install R, either from the source or from the pre-compiled binaries are
distributed from the internet site of the Comprehensive R Archive Network (CRAN) where
the instructions for installation are also available.
 R can be installed from the link http://www.r-project.org using internet connection.
 Use the “Download R” link in web page to download the R Executable.
 Choose the version of R that is suitable for your operating system.
 R-Scripts can run without the installation of the IDE, the R-Studio using the R-Console.
 Once R installation is completed we install R-Studio.
 For installation of R-Studio in Windows operating system, we download the latest
precompiled binary distribution from the CRAN website http://www.rstudio.org.
 Once completed, launch RStudio IDE from Start à All Programs à Rstudio à RStudio.exe or
from your custom installation directory.
 The default installation directory for RStudio IDE is “C:\Program Files\RStudio\bin\
rstudio.exe.
 R Studio is an Integrated Development Environment (IDE) that consists of a GUI with four
parts – 1) A text editor 2) command-line interpreter 3) place to display files, plots, packages
and help information 4) place to display the data being used and the variables used in the
program (Environment/ History).
Initiating R
First Program
 Open R Gui, find the command prompt and type the command below and hit
enter to run the command.
> sum(1:5)
[1] 15
o The result above shows that the command gives the result 15.
o That is the command has taken the input of integers from 1 to 5 and has performed the sum
operation on them.
o In the above command sum() is a function that takes the argument 1:5 which means a vector
that consists of a sequence of integers from 1 to 5.
o Like any other command prompt, R also allows to use the up arrow key to revoke the previous
commands.
Help in R :
 If a function name or a dataset name is known then we can type? followed by the name.
 If name is not known then we then we need to type?? followed by a term that is related
to the search function.
 Keywords, special characters and two separate terms of search need to be enclosed in
double or single quotes.
 The symbol # is used to comment a line in R Program like any other programming
language.
Assigning Variables
 The results of the operations in R can be stored for reuse.
 The values can be assigned to the variables using the symbol “<-” or “=” of which the
symbol “<-” is preferred.
 There is no concept of variables declaration in R.
 The variable type is assumed based on the value assigned.
 The variable names consist of letters, numbers, dots and underscores,
 but a variable name should only start with an alphabet.
 The variable names should not be reserve words.
 To create global variables (variables available everywhere) we use the symbol “<<-”.

X <<- exp(exp(1))
 Assignment operation can also be done using the assign() function.
 For global assignment the same function assign() can be used, but, by including an extra
attribute globalenv().
 To see the value of the variable, simply type the variable in the command prompt.
 The same thing can be done using a print() function.
 If assignment and printing of a value has to be done in one line we can do the same in two
ways.
 First method, by separating the two statements by a semicolon and the second method is by
wrapping the assignment in parenthesis () as below.
Basic Mathematical Operations;
 The “+” plus operator is used to perform the addition operation.
 It can be used to add two numbers or add two vectors.
 Vector represents an ordered set of values.
 Vectors are mainly used to analyse statistical data.
 The “:” colon operator creates a sequence.
 Sequence is a series of numbers within the given limits.
 The “c()” function concatenates the values given within the brackets “(“ and “)”.
 Variable names in R are case sensitive.
 Open R Gui, find the command prompt and type the command below and hit
enter to run the command.
 The vectors and the c() function in R helps us to avoid loops.
 The statistical functions in R can take the vectors as input and produce results.
 The sum() function takes vector arguments and produces results.
 But, the median() function when taking the vector arguments shows errors.
 Similar to the “+” plus
operator all other operators
in R take vectors as inputs
and can produce results.
 The subtraction and the
multiplication operations
work as below.
 The division operator is of three types.
 The ordinary division is represented using the
“/” symbol,
 the integer division operator is represented
using the “%/%” symbol
 and the modulo division operator is represented
using the “%%” symbol.
 The below example commands show the results
of the division operators.
 The other mathematical functions are the trigonometry functions like, sin(),
cos(), tan(), asin(), acos(), atan() and the logarithmic and exponential functions
like log(), exp(), log1p(), expm1().
 All these mathematical functions can operate on vectors as well as individual
elements.
Relational operators.

 The operator “==” is used for comparing two values.

 For checking inequalities of values the operator “!=” is used.
 The relational operators also take the vectors as input and operate on them.
 The other relational operators are the “< “, “> “, “<= “ and “>=
• Non-integers cannot be compared using the operator “==” as it produces wrong
results due to rounding off error of the float numbers being compared.
• For overcoming this issue we have the function all.equal().
• If the value to be compared by the function all.equal() is not equal, it returns a
report on the difference.
• To get a TRUE or FALSE reply, the all.equal() function has to be wrapped using
the function isTRUE().
• The equality operator “==” can also be used to compare strings, but, string
comparison is case sensitive.
• Similarly, the operators “<” and “>” can also be used on strings.
Packages in R
 R Packages are installed in an online repository called CRAN (Comprehensive
R Archive Network).
 A Package is a collection of R functions and datasets.
 Currently, the CRAN package repository features 10756 available packages.
 The list of all available packages in the CRAN repository can be viewed from
the web site
“https:// cran.r-project.org/web/packages/available_packages_by_name.html”.
 To find the list of functions available in a package (say the package is “stats”)
we can use the command ls(“package:stats”) or the command library(help =
stats) in the command prompt.
 A library is a folder in the machine that stores the files for a package.
 If a package is already installed on a machine we can load the same using the
library() function.
 The name of the package to be loaded is passed to the library() function as
argument without enclosing in quotes.
 If the package name has to be programmatically passed to the library()
function, then we need to set the argument character.only = TRUE.
 If a package is not installed and if the library() function is used to load the
package, it will throw an error message.
 Alternatively if the require() function is used to load a package, it returns
TRUE if the package is already installed or it returns FALSE if the package is
not already installed.
 list and see all the packages that are already loaded using the search()
function.
 This list shows the global environment as the first one followed by the recently
loaded packages.
 The last two are special environments, namely, “Autoloads” and “base”
package.
 The function installed.packages() returns a data frame with information about all the
packages installed in a machine.
 It is safe to view the results of this using the View() function as it may list hundreds of
packages.
 This list of packages also shows the version of the package installed, location on the machine
and dependent packages.

 The function R.home(“library”)

retrieves the location on the
machine that stores all R default
packages.
 The same result can be
accomplished using the .Library
command.
 The home directory can be listed
using the path.expand(“~”) and
Sys. getenv(“HOME”) functions.
o When R is upgraded, it is required to reinstall all the packages -as different versions of R
needs different versions of the packages.
o The function .libPaths() lists all the R libraries in the installed machine.
o The first value listed is the place where the packages will be installed by default.
 The CRAN package repository
contains handful of packages that
needs special attention.
 To access additional repositories,
type setRepositories() and select
the repository required.
 The repositories R-Forge and
rforge.net contains the
development versions of the
packages that appear on the
CRAN repository.
 The function
available.packages() lists
thousands of packages in each of
the selected repository. (Note: can
use the View() function to restrict
fetching of thousands of the
packages at one go)
 There are many online repositories like GitHub, Bitbucket, and Google Code from where
many R Packages can be retrieved.
 The packages can be installed using the function install.packages() function by mentioning the
name of the package as argument to this function.
 But, it is necessary to have internet connection to install any package and write permission to
the hard drive.
 To update the latest version of the installed packages, we use the function update.packages()
with the argument ask = FALSE which disallows prompting before updating each package.
 To delete a package already installed, we use the function remove.packages() by passing the
name of the package to be removed as argument.
Environments and Functions.
Environments
o In R the variables that created need to be stored in an environment.
o Environments are another type of variables.
o Can assign them, manipulate them and pass them as arguments to functions.
o They are like lists that are used to store different types of variables.
o When a variable is assigned in the command prompt, it goes by default into the
global environment.
o When a function is called, an environment is automatically created to store the
function-related variables.
o A new environment is created using the function new.env().
Variables can be assigned into a newly created environment using the double
square brackets or the dollar operator as shown below.
The assign() function can also be used to assign variables to an environment.

Retrieving values stored

in an environment is like
list indexing or we can
use the get() function.
 The functions ls() and
ls.str() take an environment
argument and lists its
contents.
 If a variable exists can be
tested in an environment
using the exists() function.
• An environment can
be converted into a
list using the
function as.list() and
• a list can be
converted into an
environment using
the function
as.environment() or
the function
list2env().
exists() and the get() function also looks for the variables in the parent
environment.
To change this behavior we need to pass the argument inherits = FALSE.
 All environments are nested and so every
environment has a parent environment.
 The empty environment sits at the top of the
hierarchy without any parent.
 The exists() and the get() function also looks for
the variables in the parent environment.
 To change this behavior we need to pass the
argument inherits = FALSE.
The word frame is used interchangeably with the word environment.
The function to refer to parent environment is denoted as parent.frame().
The variables assigned from the command prompt are stored in the global environment.
The functions and the variables from the R’s base package are stored in the base environment.