Why R?

• Free and Open source.
• Can run on windows/Mac/Linux.
• Great extensibility.
• Can integrate with other languages(C, C++, Java, Python) and packages(SAS, SPSS).
• Statistics, Data visualization (Graphs & Images)
• Graphical User Interfaces (GUI)
• R and Python are both open-source programming languages with a large community.
• R is mainly used for statistical analysis while Python provides a more general approach to data science.

R Studio

• 4 panes in 4 quadrants.
• Can change size of quadrants using splitters or buttons on top.
•  An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development.
• Tools provided by an IDE include a text editor, a project editor, a tool bar, and an output viewer.
• IDEs can perform a variety of functions ( write code, compile code, debug code, and monitor resources).

Packages

• R packages are a collection of R functions, complied code and sample data.
• They are stored under a directory called “library” in the R environment.
• By default, R installs a set of packages during installation. More packages are added later, when they are needed for some specific purpose.
• Task specific (developed for particular set of tasks).

Built-in Help Commands

• Help mechanisms (help, demo, vignette) that work on information available and installed on your computer.
• R functions are case-sensitive.
• Click Ctrl+Enter or Run to execute the command.

help()

• help(term) or ?term if know the exact term for document to be searched.
• help.search(‘term’) or ??term if don’t know the exact search term.
• example() to directly execute the example given in that document (rnorm here). It gives an idea about its usage and these examples are mostly reproducible in nature, can simply copy-paste to execute those.

Codes for help command

1. help(rnorm) #search exact term
2. ?rnorm #shortcut to search exact term
3. example(rnorm) #to diectly execute examples available in this documentation
4. help.search(‘rnorm’) #search simialr (not exact) term
5. ??rnorm #short syntax to search simialr (not exact) term

demo()

• Demos are like examples but tend to be longer. Instead of focussing on a single function, they show how to weave together multiple functions to solve a problem.
• Demos are feature specific but not available for all functions/features.
• demo(graphics) pass a topic name (again, graphics here) as a parameter to demo function. Optionally can also mention package name as a parameter.Console will prompt to hit enter key to start. Again, press enter to see next plots.

Codes for demo command

1. demo() #List demonstrations in all attached packages. (shown with checked check-boxes under package panel)
2. demo(package= .packages(all.available= TRUE)) #List demonstrations in all installed packages
3. demo(package= ‘graphics’) #List demonstrations in specific package such as graphics here
4. demo(‘graphics’) #demonstrate graphics topic, using enter key in console,in plots section
5. demo(‘graphics’,package= ‘graphics’) #demonstrate graphics topic,optionally giving package name too

vignette()

• Demos are feature specific. To know more about a package as a whole we can use vignette option.
• Cover all or part of functionality of a package.
• Each vignette provides three things: the original source file, a readable HTML page or PDF, and a file of R code. 
• Short to mid size pdf document; covers brief introduction, background, usage, result, references.

Codes for vignette command

1. vignette() #List all vignette in attached packages
2. vignette(package=.packages(all.available=TRUE)) #List all vignette in all installed packages
3. vignette(package= ‘parallel’) #List all vignette topics in parallel package
4. vignette(‘parallel’) #show vignette(pdf) for topic parallel
5. vignette(‘parallel’,package =’parallel’) #show vignette(pdf) for topic parallel using package name optionally.

Web Search

• If information is not available on our local machine then we can use power of web to find it, through either of following two ways.
• Using R command(console)-limited search uses.
• Using various popular search engines.

Web search using R command

• RSiteSearch command to invoke a website from R console.
• This function can search keywords or phrases in various help pages, vignettes and task views.
• uses search engine of R project available at following link
• http://search.r-project.org
• Click on search-key term will be highlighted as red.
• Can filter search results by choosing target (function, vignette or task view)
• can sort the search results as per need (by default search is done by score value-signifies total number of occurrence of key term in the search result.
• Search results can contain all or one of the search terms in any order.
• Have to put search terms in curly braces-If want to have exact search with both key terms occurring together.
• install.packages(‘sos’) to install any package (sos here)
• library(sos) we have to load that library into the memory before we can use any function of the sos package.
• findFn Now we can invoke the functions available in this sos package using this function name.
• Description and Link (last column) have links to actual search help page.
• Package column shows name of package containing the help page.
• Function column contains the help page name.
• Count column- total number of matches in the current package.
• Score column- score values coming from RSiteSearch function output.
• Maxscore column- maximum of the score value of the various help pages in corresponding package.
• Totalscore column– sum of all scores for particular package.
• maxPages parameter can be set if want to reduce the number of search pages or see the top pages.
• ??? is Shortcut to findFn function

• Count is package specific(number of link/help page/functions in packages having key term)
• Score is link/help page specific (occurrence of key term in specific link page) .
• Example-for search term “inheritance” packages may include three books-Python, Genetics and social science (count=3). Help pages may correspond to number of chapters in each book.Each chapter having different occurrence of key term makes score of each chapter.

Codes for web search

1. RSiteSearch(“arithmetic%20mean”)#to search from http://search.r-project.org
2. RSiteSearch(‘{arithmetic%20mean}’)#exact search all key terms occurring together
3. install.packages(‘sos’) #to install sos package
4. library(sos) #to load sos package
5. findFn(‘{arithmetic mean}’) #search function using findFn in tabular form
6. findFn(‘{arithmetic mean}’,maxPages=2) #maxPages parameter to get top pages
7. ???'{arithmetic mean}'(2) #shortcut for findfn function with maxPages parameter

Communities

Mailing List

• R-help for primary help.
• R-devel for code development in R.
• R-sig-finance, R-sig-hpc for special interest groups.
• http://bit.ly/mailingR

Forums

• http://bit.ly/stackoverflowR
• http://bit.ly/crossvalidatedR (statistics and data-mining questions in R)
• http://bit.ly/nabbleR

Blogs

• http://bit.ly/Rbloggers
• http://bit.ly/revolutionanalyticsR
• http://bit.ly/rstatistics
• http://bit.ly/rdataminig
• http://bit.ly/RPostingGuide (guidelines to post queries)

Object

• An object, in object-oriented programming (OOP), is an abstract data type created by a developer. A simple example of an object may be a user account created for a website.
• Objects have states and behaviors. Example: A dog has states – color, name, breed as well as behaviors – wagging the tail, barking, eating.
•  Object is an instance of a class.
• Class can be defined as a template/blueprint for creating a futute objects (a particular data structure),that describes the initial values for state (member variables or attributes), and implementations of behavior (member functions or methods).

Variable

• Variable is a place holder or container that can holds any object.
• We can use assignment operater (<-) along with spaces (to increase program readability) before & after to assign any value to a variable (X).
• X <- 10
• R varaibles are case-sensitive. (X is different from x).

Function

• Function is a group of statements that together perform a task.
• Function can be seen as a box that takes some value and perform some actions.
• A function is an object. R interpreter passes control to the function, along with arguments necessary for the function to accomplish the actions.
• The function in turn performs its task and returns control to the interpreter as well as any result which may be stored in other objects.
• A function is a piece of code that is independently called by name.
• A method is also a piece of code that is called by a name that is associated with an object.
• function applies to both OOP (obect-oriented) and non OOP non-object oriented languages (C, Fortran, COBOL, Pascal)
• Method applies to only object oriented languages(C, C++, Java).

Parameter & Arguement

• Parameters are components of functions. They identify values that are passed into a function.
• Parameter is variable in the declaration of function. While, Argument is the actual value of this variable that gets passed to function.
• Passing an argument to a program means setting the value of parameter of that program.

Creating a variable in a new (custom) environment

• Environment can be considered as a bag to store variables.
• It is used in lexical scoping.
• When we crearte a variable x, it is created by default in the global environment.
• When we crearte a variable in a custom environment (inside parent global environment) also. Same variables can have different values in different environments.
• To make sure that variable we created belongs to the global environment we can use get command
• get (“x”, globalenv())
• To create a new environment (named my.environment) we can use command
• my.environment <- new.env ()
• We can check parent environment to this new custom environment by following R function.
• parent.env (my.environment)
• We can create a variable in this new custom environment by 3 different ways.
• assign (“x”, 10, my.environment)
• my.environment [[“x”]] <-10
• my.environment$x <-10 (quotes around variable name are optional)
• we can read above command as ‘ assign the value of 10 to variable “x” in the environment named as my.environment.

Code for creating a variable in a new (custom) environment

1. my.environment <- new.env ()
2. assign (“comprehensive.marks”, 120, my.environment)
3. my.environment [[“comprehensive.marks”]] <-120
4. my.environment$x <-10

Getting a variable from a environment

• We can use “get” command to get a variable by passing the name of variable as well as name of environment as the parameters.
• get (“x”, my.environment)
• my.environment [[“x”]](quotes around variable name are optional)
• my.environment$x

Code for getting a variable from a environment

1. get (“comprehensive.marks”, my.environment)
2. my.environment [[“comprehensive.marks”]]
3. my.environment$comprehensive.marks # (quotes around variable name are optional)

1. comprehensive.marks <- 100 # assign variable in global environment
2. comprehensive.marks # get variable from global environment
3. get (“comprehensive.marks”, globalenv())# get variable from global environment (confirm it’s in global environment)
4. my.environment <- new.env ()# create a new custom environment
5. parent.env (my.environment)# check parent environment
6. assign a variable in this new custom environment by 3 different ways. can select all 3 lines and run together.
   • assign (“comprehensive.marks”, 120, my.environment)
   • my.environment [[“comprehensive.marks”]] <-120 #(quotes around variable name are optional)
   • my.environment$x <-10
7. to get a variable by 3 different ways.
   • get (“comprehensive.marks”, my.environment)
   • my.environment [[“comprehensive.marks”]]
   • my.environment$comprehensive.marks # (quotes around variable name are optional)

Naming convention

• Syntactically valid name consist of-
  • letter, number, dots or underline characters.
  • starts with either letter or dot followed by letter(not number), ex-goodName, good.Name, good_Name, .goodName are
  • .4goodName is an invalid name.
  • We cannot use few reserve keywords (with some semantic definition in R) for naming in R. ex-function, for, if, else, while, next, repeat, TRUE, FALSE, NULL, NA, NaN etc.

Google’s R Style Guide

• For not only syntactically valid but also more consistent and readable variable names.
• File Names
  • File names should end in .R and be meaningful.
  • GOOD: predict_ad_revenue.R
  • BAD: foo.R
• Identifiers
• Variable names should have all lower case letters and words separated with dots (.) Don’t use underscores ( _ ) or hyphens (-).
• variable.name
  GOOD: avg.clicks
  BAD: avg_Clicks , avgClicks
• Function names have initial capital letters and no dots (CapWords).Make function names verbs.
• FunctionName
  GOOD: CalculateAvgClicks
  BAD: calculate_avg_clicks , calculateAvgClicks
  
  Exception: When creating a classed object, the function name (constructor) and class should match (e.g., lm).
• kConstantName
• http://web.stanford.edu/class/cs109l/unrestricted/resources/google-style.html

How to assign a variable

• By using assignment operator (less than sign folloed by dash). Use “run” to execute this line. We can see this execution on the bottom console.
• If we want to see the content of varaible, we can simple execute the variable name.
• comprehensive.marks <- 100
• By using assign () function. Assign function can take several parameters. In the example below, first parameter is the variable name and second parameter is the value we want to assign it.
• assign ( “comprehensive.marks”, 100)
• Whenever we create a variable that is also created in environment tab on right panel.

Codes for assigning a variable

1. comprehensive.marks <- 100 # assign value to a variable using assignment operator
2. comprehensive.marks # print variable content
3. assign (“match.score” , 500) # assign value to a variable using assign function
4. match.score # print variable content

Operator

• Operator are similar to in-buit mathematical ‘Functions’ but both are syntactically different.
  • are pillars of any programming language
  • can work on one or more objects called “Operands”
  • will return some results
  • Two types of Operators.
    • Arithmatic operator-operate on numeric values
    • Logical operator- operate on Boolean or Logical values (True or false)

Mathematical Operators in R

1. 12 + 4 #Addition
2. 12 – 4 #subtraction
3. 12 * 4 #Multiplication
4. 12 / 4 #Divison
5. 12 ^ 2 #Exponentiation (carrot symbol)
6. 12 ** 2 #Exponentiation (double multiplication symbol)
7. 10 ^ 3
8. format(10 ^ 3, scientific = TRUE) #With scientific notation
9. format(10 ^ 3, scientific = FALSE) #Without scientific notation (string format)
10. 12 %% 5 #Modulus
11. 12 %/% 7 #Integer divison

In-built Mathematical Functions in R

1. abs(-7) #Absolute value
2. log(2) #Natural Logarithm
3. log(2, base = 10) #Logarithm
4. exp(5) #exponential (e ^ 5)
5. factorial(5) #factorial
6. sqrt(625) #Square root
7. round(3.07822, digit=2) #3.08
8. signif(3.07822, digit=2) #3.1
9. ceiling(3.07822) #4
10. floor(3.07822) #3
11. We can get other Mathematical Functions in R documentation.

Special constant

1. pi #Special constant pi value
2. options () #Get global options
3. options (digits = 4) #set digits to 4 (means three digits after decimal)

Special Numbers in R

• Special Numbers allow the calculations or analyses to continue (or terminate gracefully) in adverse situations and prevent the program to crash abruptly.For example when we hit a overflow conditions.
• Positive and negative infinity (Inf and -Inf)
  • To represent overflow conditions.
  • some number that is too big or too small to be handled by computer.
• NaN (Not a Number or Undefined)
  • To represent a value that is not a real number.
  • It output doesn’t make any mathematical sense.
• NA (Not available or Missing)
  • Missing value, not available in data set.
  • In R language NaN is NA but converse is not true.

Special Numbers in R

1. 1 / 0 #Positive infinity
2. -20 / 0 #Negative infinity
3. Inf + 5 #Operation on Inf
4. -Inf + 5 #Operation on Inf
5. is.finite(1 / 0) # check if finite number (FALSE)
6. is.infinite(1 / 0) # check if infinite number (TRUE)
7. is.finite(0/1) # check if finite number (TRUE)
9. Inf / Inf #Not a Number (NaN)
10. Inf – Inf #Not a Number (NaN)
11. is.nan(Inf – Inf) #Check if NAN (TRUE)
13. NA + 4 #Missing value (NA)(operation on missing number)
14. NA – 4 #Missing value (NA)
15. NA * 4 #Missing value (NA)
16. NA / 4 #Missing value (NA)
17. is.na(NA +4) #Check if NA (TRUE)
19. is.nan(NA) #Check if NA in NaN (FALSE)
20. is.na(NaN) #Check if NaN in NA (TRUE)

• R has six basic (‘atomic‘) vector types: logical, integer, real, complex, string (or character) and raw.
• A real number is any positive or negative number. This includes all integers (whole numbers including zero) and all rational and irrational numbers. Rational numbers may be expressed as a fraction (such as 7/8) and irrational numbers may be expressed by an infinite decimal representation (3.1415926535…). Real numbers that include decimal points are also called  floating point numbers, since the decimal “floats” between the digits.
• Zero is known as the neutral integer, or the whole number that comes in the middle of positive and negative numbers on a number line, which in turn makes it an integer, but not necessarily a natural number.
• Natural numbers are the positive integers (whole numbers) 1, 2, 3, etc., and sometimes zero as well.
• https://techterms.com/definition/realnumber

Logical Operators

• Logical operators not only work on numerical values But also work on character strings.
• Boolean result for each comparison.
• Logical NOT operator will simply inverse the value inside parenthesis.
• Logical OR operator works on two logical expressions , if any of the two operands evaluates to true, then the output will be TRUE.
• For logical AND result will be TRUE only when both operands or logical expressions evaluate to true.

1. 6 < 3 #less than
2. 6 <= 3 #less than equal to
3. 6 > 3 #greater than
4. 6 >= 3 #greater than equal to
5. 6 == 3 # equal to
6. 6 != 3 #not equal to
7. “b” > “a” #comparing characters (TRUE)
8. “e” < “b” #comparing characters (FALSE)
9. !(TRUE) #logical NOT operator (inverses value inside parenthesis) (FALSE)
10. TRUE | FALSE #logical OR operator (TRUE)(TRUE when any of two operands true)
11. TRUE & FALSE #logical AND operator (FALSE) (TRUE when both logical expressions are true)

Data Structure

• Data sturucture defines the way in which data will be organized and stored in the memory.
• Data sturucture is collection of data elements grouped under one name.
• It can be seen as a container holding data elements. Selection of data structure depends upon answers to questions-
  • what type of items to put in (homo or heterogenous)
  • how to arrange-to produce different data structures (List, Vector, Factor, Data frame, Matrix, Array)
• We can use str() function to see the structure of an object.
• is.numeric() function to test if it’s a numeric vector.
• Most of the data in real word is either objects or basic/atomic classes (character, Numeric, Integer, logical and complex ) or objects that can be built using these basic classes.
• In R language we use capital “L”as suffix to explicitly mark any numeric value without a decimal part as an integer.
• Elements without”L” suffix will be trated as double values making it a numeric vector.
• Integers are basically numeric values without decimal parts. Integer can be considered as numeric vector but converse may not be true.
• 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.
• Factors: Factors are the data objects which are used to categorize the data and store it as levels. They can store both strings and integers. They are useful in data analysis for statistical modeling.
• Matrices: Matrices are the R objects in which the elements are arranged in a two-dimensional rectangular layout. A Matrix is created using the matrix() function. 
• Arrays: Arrays are the R data objects which can store data in more than two dimensions. It takes vectors as input and uses the values in the dim parameter to create an array.
• List: Lists are the R objects which contain elements of different types like − numbers, strings, vectors and another list inside it.
• Vector: A Vector is a sequence of data elements of the same basic type. 
• https://www.edureka.co/blog/r-tutorial/

Atomic Vector

• Commonly known as “Vector”.
• Homogenous data structure.
• One-dimensional arrangement of elements.
• Most of the basic functions or operators in R are vectorized in nature.
• Vectorized operators can work on one or more vectors to give some results.
• A vector is a sequence of data elements of the same basic type (numeric, chracter or boolean type).
• Members of a vector are called Components.
• We use combine function c() to create vector by combining discrete values.
• Here is a vector containing three numeric values 2, 3 and 5 : c(2, 3, 5).
• The c() function coerces non-character values to character type if one of the elements is a character.
• The syntax to access a vector a at (position) index i is, a[i]
• If we try to access elements outside of the index range, we will get the value as NA
•  We can access multiple elements of a vector using a vector of indices. The returned value is also a vector.
• We can also make some elements disappear in the returned vector by giving the indices of those elements with a negative sign.
• We can also provide TRUE and FALSE in an indices vector. When there is TRUE, the element is considered in the result and when there is FALSE, the element is not considered in the result.
• For the two vectors with length greater than one, the arithmetic operations are performed like a dot operation (one to one).
• R has six basic (‘atomic’) vector types: logical, integer, real, complex, string (or character) and raw.
• We can perform arithmetic operations (like addition, subtraction, multiplication and division).
• Importantly, the two vectors should be of same length and same type or the second vector can be an atomic value of same type.
• If the second vector is of different length, something called recycling happens to the smallest vector to match the size of the largest vector.

Create a vector

1. students.marks <-c (10,20,30,40) # create a vector using combine function
2. students.marks # print variable
3. [1] 10 20 30 40
4. students.grades <- c (“pass”, 50, “B”, “TRUE”) # create a vector using different element types
5. students.grades # print (non-character values converted to character type)
6. [1] “pass” “50” “B” “TRUE”

Atomic Vector Script

1. student.names <-c (“amar”,”bob”, “chap”, “don”) # create character vector (using combine function)
2. student.names # print vector content
3. [1] “amar” “bob” “chap” “don”
4. str (student.names) # get vector structure ( four elements indexed from [1:4])
5. chr [1:4] “amar” “bob” “chap” “don”
6. is.character (student.names ) # test character vector
7. [1] TRUE
9. student.weights <-c (70.1, 70.2, 70.3, 70.4) # create numeric vector (using combine function)
10. student.weights # print vector content
11. [1] 70.1 70.2 70.3 70.4
12. str (student.weights) # get vector structure
13. num [1:4] 70.1 70.2 70.3 70.4
14. is.numeric (student.weights) # test numeric vector
15. [1] TRUE
17. student.marks <-c (51L, 52L, 53L, 54L) # create integer vector (using combine function)
18. student.marks # print vector content
19. [1] 51 52 53 54
20. str (student.marks) # get vector structure
21. int [1:4] 51 52 53 54
22. is.integer (student.weights) # test integer vector
23. [1] FALSE
25. is.numeric (student.marks) # integer is numeric without decimal part
26. [1] TRUE
27. is.integer (student.weights) # numeric maynot be integer
28. [1] FALSE
30. student.maths.interest <-c (T, TRUE, F, FALSE) # create logical vector (using combine function)
31. student.maths.interest # print vector content
32. [1] TRUE TRUE FALSE FALSE
33. str (student.maths.interest) # get vector structure
34. logi [1:4] TRUE TRUE FALSE FALSE
35. is.logical (student.maths.interest) # test logical vector
36. [1] TRUE
37. complex.vector <-c (10+2i, -10+2i, 10-2i) # create complex vector (using combine function)
38. complex.vector # print vector content
39. [1] 10+2i -10+2i 10-2i
40. str (complex.vector) # get vector structure
41. cplx [1:3] 10+2i -10+2i 10-2i
42. is.complex (complex.vector) # test complex vector
43. [1] TRUE
45. vector (“character”, length = 4) # create character vector (using vector command (default:empty string)
46. [1] “” “” “” “”
47. vector (“numeric”, length = 4) # create numeric vector (using vector command)(default:0)
48. [1] 0 0 0 0
49. vector (“integer”, length = 4) # create integer vector (using vector command)
50. [1] 0 0 0 0
51. vector (“logical”, length = 4) # create logical vector (using vector command)(default:FALSE)
52. [1] FALSE FALSE FALSE FALSE
53. vector (“complex”, length = 4) # create complex vector (using vector command)(default:0+i0)
54. [1] 0+0i 0+0i 0+0i 0+0i

Subsetting or Access vector component

• Subsetting is the process of extracting one or more elements from any data structure (vector here).
• In R there is 1 based index.
• Use [] to access an element.

Subsetting/Extraction/Accessing vector elements

1. students.marks [3] # to access vector at third position (index)
2. [1] 30
3. students.marks [5] # to access vector element outside the index range
4. [1] NA
5. students.marks [1:3] # access multiple elements in a sequence using colon operator (1 through 3 here)
6. [1] 10 20 30
7. student.marks [c(T,F,T,F)] #access multiple elements specifying logical vector
8. [1] 10 30
9. students.marks [c(1,4)] #access multiple elements specifying index vector
10. [1] 10 40
11. student.names <- c(“amar”,”bob”,”chap”,”don”) #create vector using combine function
12. [1] “bob” “chap” “don”
13. student.names [students.marks >= 20] #access multiple elements specifying logical vector
15. indices <- c(1,3) # create vector of indices
16. students.marks [indices] # access multiple elements of a vector using a vector of indices
17. [1] 10 30
18. neg.indices <- c(-1, -3) # create vector of negative indices to make some elements disappear
19. students.marks [neg.indices] # print to make some elements disappear
20. [1] 20 40
21. bool.indices <-c (TRUE, FALSE, TRUE, FALSE) # create logical vector (TRUE, FALSE) of indices
22. students.marks [bool.indices] # using TRUE and FALSE in an indices vector
23. [1] 10 30
24. bool.indices.short <-c (T,F,T,F) # create logical vector of indices (T & F)
25. student.marks [bool.indices.short] #access element
26. [1] 10 30

Coercions/ Typecasting/ Type conversion

• Converting one type to another.
• Whenever there is mixing of data type coercion will occur.
• Typesetting can be Implicit or Explicit (may or may not be Sensible)

Coercion script

1. student.weights <- c(50.1,50.2,50.3,50.5) #create numeric(double) atomic vector
2. str (student.weights) #print data structure
3. num [1:4] 50.1 50.2 50.3 50.5
4. student.weights <- c(50.1,50.2,50.3,’50.5′) #Implicit coercion due to mixing of data types
5. str (student.weights) #print converted data structure
6. chr [1:4] “50.1” “50.2” “50.3” “50.5”
8. as.numeric (student.weights >= 50.3) # converting logical values (T,F) to numeric values(1,0)
9. [1] 0 0 1 1
10. as.integer (student.weights) #converting numeric to integer vector
11. [1] 50 50 50 50
12. as.character(student.weights) #converting numeric to character
13. [1] “50.1” “50.2” “50.3” “50.5”
14. as.logical(student.weights) #converting numeric values to logical values (Insensible coercion)
15. [1] NA NA NA NA
16. student.names <- c(“amar”,”bob”, “chap”, “don”) #create character atomic vector
17. as.numeric (student.names) #converting names to logical values (Insensible coercion)
18. [1] NA NA NA NA
19. Warning message:
20. NAs introduced by coercion

R Vector Arithmetic & Logical Operations

1. students.test.marks <- c(1,2,3,4)
2. add1.student.marks <-students.marks + 2 # arithmetic operations performed like a dot operation (one to one).
3. add1.student.marks # print variable
4. [1] 12 22 32 42
5. add2.student.marks <-students.marks + students.test.marks # arithmetic operations performed like a dot operation (one to one).
6. add2.student.marks # print variable
7. [1] 11 22 33 44
8. sub1.student.marks <- students.marks – 2 #R Vector Subtraction
9. sub1.student.marks # print variable
10. [1] 8 18 28 38
11. sub2.student.marks <- students.marks – students.test.marks #R Vector Subtraction
12. sub2.student.marks # print variable
13. [1] 9 18 27 36
14. mul1.students.marks <- students.marks * 2 #R Vector Multiplication
15. mul1.students.marks # print variable
16. [1] 20 40 60 80
17. mul2.students.marks <- students.marks * students.test.marks #R Vector Multiplication
18. mul2.students.marks # print variable
19. [1] 10 40 90 160
20. div1.students.marks <- students.marks %/% 2 #R Vector integer divison
21. div1.students.marks # print variable
22. [1] 5 10 15 20
23. div2.students.marks <- students.marks %/% students.test.marks #R Vector integer divison
24. div2.students.marks # print variable
25. [1] 10 10 10 10
26. students.less.marks <- c(1,2) # create vector with different length
27. recycle.students.less.marks <- students.marks + students.less.marks # smallest Vector Element Recycling
28. recycle.students.less.marks # print variable
29. [1] 11 22 31 42
31. students.marks >= 20 # R vector logical operation
32. [1] FALSE TRUE TRUE TRUE

Vectorized Operations

1. Vectorized operations: Flavor I: Input= single vector, Output= Scalar(vector of length 1)
2. mean(students.marks) # print variable
3. [1] 25
4. Vectorized operations: Flavor II: Input= single vector, Output= single vector
5. student.marks <-students.marks + 1 #arithmatic operator
6. student.marks # print the content of new vector students.marks
7. [1] 11 21 31 41
8. student.marks >= 12 # logical operator
9. [1] FALSE TRUE TRUE TRUE
10. sqrt (students.marks) # print the content of variable
11. [1] 3.162278 4.472136 5.477226 6.324555
12. Vectorized operations: Flavor III: Input= multiple vector, Output= single vector
13. total.students.marks <- students.marks + students.test.marks # addition
14. total.students.marks # print the content of vector
15. [1] 11 22 33 44

Factor

• Special case of vector used to store nominal/categorical values.
• “Categorical” means field can take values from few categories only.
• “Gender” is a categorical variable as limited categories available.
• Factors are more efficient than character vectors as characters are case sensitive. Further, string comparisons (filtering) are inefficient in comparison to integer comparison.
• Factors are self-describing in contrast to integer vectors.
• We can create a factor by wrapping combine function output in the factor method. This function will also provide additional information about number of levels (categories).
• Explicit coercion of factor to numeric vector will create Implicit levels (as.numeric () function ).By default, levels are decided alphabatically.
• Explicit levels can also be created when we want to order our own levels.We can do it by creating a factor with first arguement as the combine function to provide various categories(levels) and second arguement levels with the combine function again to order levels as per our need.
• Not only we can order the levels but also can create additional levels to provide all possible levels in the problem.

Script for Factor

1. student.gender <- c(‘Male’,’Male’,’Female’,’Female’) #character vector to represent Female & Male categories
2. student.gender #print categories
3. [1] “Male” “Male” “Female” “Female”
4. student.gender <- c(2L,2L,1L,1L) #integer vector to represent Female & Male categories as 2& 1 resp.
5. student.gender #print categories
6. [1] 2 2 1 1
8. student.gender <- factor(c(‘Male’,’Male’,’Female’,’Female’)) #create factor(wrap combine function output in a factor method)
9. student.gender # print categories with levels (not wrapped in quotes)
10. [1] Male Male Female Female
11. Levels: Female Male
12. as.numeric (student.gender) #explicit coercion of factor to numeric vector( create Implicit levels)
13. [1] 2 2 1 1
15. student.blood.groups <- factor(c(“A”,”B”,”O”, “O”)) #create factor(wrap combine function output in a factor method)
16. student.blood.groups #print categories along with levels (no quotes)
17. [1] A B O O
18. Levels: A B O
20. student.blood.groups <- factor(c(“A”,”B”,”O”,”O”), levels = c(“A”, “B”, “AB”, “O”)) #create Explicit levels
21. student.blood.groups #creating additional levels
22. [1] A B O O
23. Levels: A B AB O
24. str(student.blood.groups) #test structure of factor with additional level
25. Factor w/ 4 levels “A”,”B”,”AB”,”O”: 1 2 4 4

List

• Heterogenous data structure-can contain different class items.
• One dimentional arrangement of elements.
• With the help of list we can extract all information of one student stored in different type of vectors using single command.
• To create a list, first we create various different vectors storing different type of information. Then, we create an unnamed list using list() function and in this list () function we can pass all desired elements by use of square bracket to get a partcular element from the designated vector ( indexing ).
• We can create a named list also by specifying a name for each parameter. This will give the name of each element after the dollar sign in the output.
• Can use str () function to get the structure of created list.
• We can use the elemnts of atomic class only as the members of list or we can also use a vector as an element in the list (List can also be a member of another list).
• We can extract one or more elements from a list using square bracket.
  • If we use single bracket to extract an object/element it will give an object of same type from which we are subsetting. If we subset, we get a vector and if we subset a list we will et a list.
  • If we use single bracket to extract an object/element it will return the type of extracted element.
  • typeof() function to get the type of extracted element.
  • We can use names (wrapped in quotes) instead of index number to extract element from named list.
  • We can also use dollar sign to extract element from named list and don’t need to use square brackets or wrap the element name in quotes.
  • We can use length() function to get the total number of elements in the list.

Script for List

1. student.names <- c(‘amar’, ‘bindu’, ‘chris’, ‘don’) #character vector
2. student.weights <- c(70.1, 70.2, 70.3, 70.5) #numeric (double)vector
3. student.gender <- factor (c(“male” , “female” ,”female”, “male” )) #factor
4. student.eng.marks <- c( 51L, 52L, 53L, 55L) #integer vector
5. student.maths.marks <- c( 61L, 62L, 63L, 65L) #integer vector
7. student1 <- list (student.names[1], student.weights[1], student.gender[1], student.eng.marks[1], student.maths.marks[1] ) # creating unnamed list
8. str (student1) #get the structure of created list
9. List of 5
10. $ : chr “amar”
11. $ : num 70.1
12. $ : Factor w/ 2 levels “female”,”male”: 2
13. $ : int 51
14. $ : int 61
15. student1 # print content of unnamed list
16. [[1]]
17. [1] “amar”
18. [[2]]
19. [1] 70.1
20. [[3]]
21. [1] male
22. Levels: female male
23. [[4]]
24. [1] 51
25. [[5]]
26. [1] 61
28. student1 <- list (name= student.names[1], weight= student.weights[1], gender= student.gender[1], english= student.eng.marks[1], maths= student.maths.marks[1] ) # creating named list
29. str (student1) #get the structure of created list
30. List of 5
31. $ name : chr “amar”
32. $ weight : num 70.1
33. $ gender : Factor w/ 2 levels “female”,”male”: 2
34. $ english: int 51
35. $ maths : int 61
37. student1 # print content of named list
38. $name
39. [1] “amar”
40. $weight
41. [1] 70.1
42. $gender
43. [1] male
44. Levels: female male
45. $english
46. [1] 51
47. $maths
48. [1] 61
49. student1 <- list (name= student.names[1], weight= student.weights[1], gender= student.gender[1], marks.eng.maths= c(student.eng.marks[1], student.maths.marks[1])) # List containig a vector as an element
50. str (student1) #get the structure of List containig a vector as an element
51. List of 4
52. $ name : chr “amar”
53. $ weight : num 70.1
54. $ gender : Factor w/ 2 levels “female”,”male”: 2
55. $ marks.eng.maths: int [1:2] 51 61
56. student1
57. $name
58. [1] “amar”
59. $weight
60. [1] 70.1
61. $gender
62. [1] male
63. Levels: female male
64. $marks.eng.maths
65. [1] 51 61
66. student2 <- list(student.names[2], student.gender[2], student.weights[2], student.eng.marks[2], student.maths.marks[2]) # craete unnamed list
67. student2 #print unnamed list
68. [[1]]
69. [1] “bindu”
70. [[2]]
71. [1] female
72. Levels: female male
73. [[3]]
74. [1] 70.2
75. [[4]]
76. [1] 52
77. [[5]]
78. [1] 62
79. str(student2) #get structure of created list
80. List of 5
81. $ : chr “bindu”
82. $ : Factor w/ 2 levels “female”,”male”: 1
83. $ : num 70.2
84. $ : int 52
85. $ : int 62
86. typeof(student2) #get type of created object
87. [1] “list”
88. student2 [2] #extract element from unnamed list using single square bracket
89. [[1]]
90. [1] female
91. Levels: female male
92. typeof(student2 [2]) #get type of extracted object (same as from which element was extracted)
93. [1] “list”
94. student2 [[2]] #extract element from unnamed list using double square bracket
95. [1] female
96. Levels: female male
97. typeof( student2 [[2]]) #get type of extracted object (type of extracted object itself)
98. [1] “integer”
99. student2 [1:3] #extract multiple elements from unnamed list using single square bracket
100. [[1]]
101. [1] “bindu”
102. [[2]]
103. [1] female
104. Levels: female male
105. [[3]]
106. [1] 70.2
107. student3 <- list(name= student.names[3], gender= student.gender[3], weight= student.weights[3], eng= student.eng.marks[3], maths= student.maths.marks[3])# create named list
108. student3 [“gender”] #extract element from named list using element name wrapped in quotes
109. $gender
110. [1] female
111. Levels: female male
112. student3 $ gender # extract element from named using dollar sign without quotes
113. [1] female
114. Levels: female male
115. student3 [ c(“gender”, “name” , “weight”)] #extract multiple elements from named list using combine function to create a character vector
116. $gender
117. [1] female
118. Levels: female male
119. $name
120. [1] “chris”
121. $weight
122. [1] 70.3
123. length(student3) #get the total number of elements in the list
124. [1] 5

Data frames

• Data frames are most popular data structures.
• Heterogenous-can contain elements of different classes (like list).
• 2-dimensional arrangement (unlike list).
• Data frames are like spread-sheets; each column represents a field and values are stored in the rows.
• If we want to get details of all the students of the class we can pass our atomic vectors to data.frame () function.
• However, each object passed in data.frame function should have an equal number of elements.
• Data frames are actually a type of list (we get ” list” when use typeof () function) where each element of the list is a vector of equal lengths. Vector variable names become field/column names and the values are stored in data rows.
• Head = top line with field/column/vector names
• Cell = Each value in data row
• “Character” string values are treated as “factor” by default in data frames.
• to remove this default behaviour we can set Boolean paramer stringasFactor = FALSE

Script for Data frame

1. student.names <- c(“amar” , “bindu” , “chris” , “don” ) #character vector
2. student.gender <- factor(c(‘male’, ‘female’, ‘female’, ‘male’)) # factor
3. student.weights <- c(70.1, 70.2, 70.3, 70.5) #numeric (double)vector
4. student.eng.marks <- c(51L, 52L, 53L,55L) #integer vector
5. student.maths.marks <- c( 61L, 62L, 63L, 65L) #integer vector
7. all.students <- data.frame (student.names, student.gender, student.weights, student.eng.marks, student.maths.marks) # create a data frame named all.students
8. all.students #print content of created data frame
9. 
11. typeof(all.students) #get type of created data frame
12. [1] “list”
13. str(all.students) #get structure of created data frame
14. ‘data.frame’: 4 obs. of 5 variables:
15. $ student.names : Factor w/ 4 levels “amar”,”bindu”,..: 1 2 3 4
16. $ student.gender : Factor w/ 2 levels “female”,”male”: 2 1 1 2
17. $ student.weights : num 70.1 70.2 70.3 70.5
18. $ student.eng.marks : int 51 52 53 55
19. $ student.maths.marks: int 61 62 63 65
21. all.students <- data.frame (student.names, student.gender, student.weights, student.eng.marks, student.maths.marks, StringsAsFactors = FALSE) # use stringsAsFactors = FALSE to avoid conversion of character vector to factor
22. all.students #print content of created data frame
23. 
25. typeof(all.students) #get type of created data frame
26. [1] “list”
27. str(all.students) #get structure of created data frame
28. ‘data.frame’: 4 obs. of 5 variables:
29. $ student.names : chr “amar” “bindu” “chris” “don”
30. $ student.gender : Factor w/ 2 levels “female”,”male”: 2 1 1 2
31. $ student.weights : num 70.1 70.2 70.3 70.5
32. $ student.eng.marks : int 51 52 53 55
33. $ student.maths.marks: int 61 62 63 65

Script for operations on Data frame

1. student.names <- c(“amar” , “bindu” , “chris” , “don” ) #create character vector
2. student.gender <- factor(c(‘male’, ‘female’, ‘female’, ‘male’)) # factor
3. student.weights <- c(70.1, 70.2, 70.3, 70.5) #numeric (double)vector
4. student.eng.marks <- c(51L, 52L, 53L,55L) #integer vector
5. student.maths.marks <- c( 61L, 62L, 63L, 65L) #integer vector
7. #create dataframe while using stringsAsFactors = FALSE to avoid conversion of character vector to factor
8. all.students <- data.frame (student.names, student.gender, student.weights, student.eng.marks, student.maths.marks, stringsAsFactors = F)
9. all.students #print content of created data frame
11. #subsetting data frame (first element means first column from data frame)
12. all.students [1] #single square bracket to return object of same type (from which we extract)
13. student.names
14. 1 amar
15. 2 bindu
16. 3 chris
17. 4 don
18. typeof(all.students [1])
19. [1] “list”
20. all.students [[1]] #double square bracket to return object in its own type (element type)
21. [1] “amar” “bindu” “chris” “don”
22. typeof(all.students [[1]])
23. [1] “character”
24. # use column name instead of index to extract it
25. all.students [“student.weights”] # single square bracket to return object of same type
26. student.weights
27. 1 70.1
28. 2 70.2
29. 3 70.3
30. 4 70.5
31. typeof(all.students [“student.weights”])
32. [1] “list”
33. all.students [[“student.weights”]] #double square bracket to give object of its own type
34. [1] 70.1 70.2 70.3 70.5
35. typeof(all.students [[“student.weights”]] )
36. [1] “double”
37. all.students$student.weights # dollar sign (with column name) to return object in its own type
38. [1] 70.1 70.2 70.3 70.5
39. typeof(all.students$student.weights)
40. [1] “double”

Script to extract multiple elements (slice of data frame)

1. all.students
2. 
4. all.students [1:3] # colon or sequence operator to extract slice of first through third column
5. 
7. all.students [ c(“student.weights”, “student.names”) ]# combine function to extract two columns together
8. 
10. all.students [3,2] # Row, Column (extract individual cell located at third row & second column)
11. [1] female
12. Levels: female male
13. all.students [1:3,1:2] #colon or sequence operator to extract consecutive rows and columns)(first three rows & first two columns)
14. 
16. all.students [ c(1,2,3), c(1,2)] #combine function to extract individual cells
17. 
19. all.students [,3] #unspecified row number(get all rows for third column)
20. [1] 70.1 70.2 70.3 70.5
21. all.students [1,]#unspecified column number (get all columns for first row)
22. 
24. all.students [c(T,F,F,T),]# logical vector to pick required rows of all columns
25. 
26. all.students [,c(T,F,F,F,T)]# logical vector to pick required column for all rows
27. 
29. all.students [c(T,F,F,T),1:2] #extraction using both sequence operator and combine function
30. 
32. all.students [student.gender == “female”, ] #logical operator to get details of only female students
33. 
35. all.students [student.eng.marks == 51, ]
36. 
38. all.students [student.eng.marks > 51, ]
39. 
41. all.students [student.eng.marks >= 53, 1:2 ]
42. 

Matrix

• 2-dimensional arrangement (similar to Data frames and spreadsheets) but are homogenous in nature (unlike Data frames) and can store elements of same type only.
• Typically, Matrices are used to store & process numeric data.
• rbind() function for row-wise binding of matrix. Variable names are ‘Row-names’ and column names are auto-generated as comma followed by index number.
• cbind() function for column-wise binding of matrix. Variable names are ‘Column names or Head’ while Row names are auto-generated as index number followed by a comma.
• We can customize row names by passing the created matrix as an arguement in the rownames() function on the left hand side of assignment operator. On the right hand side we create a character vector using combine function.
• str() function can be used to test the structure of created matrix.
• Dimnames or dimension names is a list which contains row names and column names.
• Matrix can also be constructed using matrix ()function. As the first parameter to this function we will use combine function to create an integer vector. As second and third parameter we will use ncol=x and nrow =y to designate the number of columns and rows respectively. Row names as well as column names are auto-generated.
• If we use matrix() function to create a matrix, by default the elements will be arranged column-wise. first of all, the first column will be filled , then the second column will be filled and then so on.
• Techniques of extracting elements from Matrix are similar to that of used for extracting elements from Data frames.

Script for Matrix

1. student.eng.marks <- c(61L, 62L, 63L, 65L) #integer vector
2. student.maths.marks <- c(71L, 72L, 73L, 75L) #integer vector
3. student.marks <- rbind (student.eng.marks, student.maths.marks) #row-wise matrix binding
4. student.marks #print content of(row-wise)created matrix
5. 
7. student.marks <- cbind (student.eng.marks, student.maths.marks) #column-wise matrix binding
8. student.marks #print content of(column-wise)created matrix
9. 
10. rownames(student.marks) <- c(“amar”, “bindu”, “chris”, “don”) #customize row-names for column bound matrix
11. student.marks #print content of(column-wise)created matrix with customized row-names
12. 
14. str(student.marks) #get structure of matrix with dimnames (cbind function)
15. 
17. student.marks <- matrix(c(61L, 62L, 63L, 65L,71L, 72L, 73L, 75L), ncol=4, nrow=2)# matrix function to create matrix (default column-wise item arrangement)
18. student.marks #print content of created matrix(default column-wise, c=4,r=2)
19. 
20. student.marks <- matrix(c(61L, 62L, 63L, 65L,71L, 72L, 73L, 75L), nrow=4, ncol=2 ) #create matrix(default column-wise, r=4,c=2)
21. student.marks #print content of created matrix(default column-wise, r=4,c=2)
22. 
24. student.marks <- matrix(c(61L, 62L, 63L, 65L,71L, 72L, 73L, 75L), ncol=4, nrow=2, byrow= TRUE) #row wise item arrangement
25. student.marks # print content of this row-wise matrix
26. 
27. str(student.marks) #get structure of matrix without dimnames (matrix function)
28. int [1:2, 1:4] 61 71 62 72 63 73 65 75
29. rownames(student.marks) <-c(“amar” , “bindu”)
30. student.marks
31. 

Script for Matrix Operations

1. student.eng.marks <- c(61L, 62L, 63L, 65L) #integer vector
2. student.maths.marks <- c(71L, 72L, 73L, 75L) #integer vector
3. student.marks <- cbind (student.eng.marks, student.maths.marks) #column-wise matrix binding
4. rownames(student.marks) <- c(“amar”, “bindu”, “chris”, “don”) #customize row-names for column bound matrix
5. student.marks #print content of(column-wise)created matrix with customized row-names
6. 
7. str(student.marks) #get structure of matrix with dimnames (cbind function)
8. 
10. #Subsetting or extracting elements from Matrix [Row, Column]
11. student.marks[3,2] #extract single cell
12. [1] 73
13. student.marks[,] #extract all rows & all columns
14. 
15. student.marks[,2] #extract all rows with specified column
16. 
17. student.marks[2,] #extract specified row with all columns
18. 
19. student.marks[2:4,1] #colon or sequence operator for consecutive rows
20. 
21. student.marks[c(1,3), ] #combine function (integer vector)to extract individual rows and all columns
22. 
23. student.marks[c(T,F,T,F), 2] #logical vector (combine function) to extract individual rows and specified column
24. 
26. #Matrix Summary
27. student.marks #print content of(column-wise)created matrix with customized row-names
28. 
29. rowSums(student.marks) #Row-wise sum
30. 
31. colSums(student.marks) #Column-wise sum
32. 
33. colMeans(student.marks) #Column wise mean
34. 

REFERENCES

• http://web.stanford.edu/class/cs109l/unrestricted/resources/google-style.html
• https://www.edureka.co/blog/r-tutorial/