R교육1

Definition of data
“ Data are values of qualitative or
quantitative variables, belong to a
set of items.”
Set of items : Sometimes called the population; the set of objects you are interested in.
Variables : A measurement or characteristic of an item
Qualitative : Country of origin, sex, treatment...
Quantitative : Height, weight, blood pressure...

The data is the second most important thing
 The most important thing in data science is the question
 The second most important is data
 Often the data will limit or enable the question
 But having data can’t save you if you don’t have a question

무엇을 함께 고민할까?
R 프로그래밍 데이터의 추출과 정제 데이터의 탐색적 분석
재현성 있는 리서치 통계적 추론 회귀모델
기계학습 데이터의 분석 도출

Getting and Cleaning Data Content
 Raw vs. tidy data
 Downloading files
 Reading data
- Excel, XML, JSON, MySQL, HDF5, Web...
 Merging data
 Reshaping data
 Summarizing data
 Finding and replacing
 Data resource

Exploratory Data Analysis
 Principles of Analytic Graphics
 Exploratory Graphs
 Plotting System in R
 Base Plotting System
 Base Plotting Demonstration
 Graphics Devices in R
 Lattice Plotting System
 ggplot2
 Hierarchical Clustering
 K-Means Clustering
 Dimension Reduction
 Working with Color in R Plots

Practical Machine Learning
 What is prediction?
 Type of errors
 Cross validation
 Caret package
 Training options
 Predicting with Regression
 Predicting with trees
 Bagging
 Boosting
 Model Based Prediction

Why R?
 It is free
 It has a comprehensive of packages
- Data access
- Data cleaning
- Analysis
- Data reporting
 It has one of the best development environments
 It has an amazing ecosystem of developers
 Packages are easy to install and “play nicely togther”

Objects
R has five basic or “atomic” classes of objects:
 character
 numeric(real number)
 integer
 complex
 logical(TRUE/FALSE)
The most basic object is a vector
 A vector can only contain objects of the same calss
 BUT: The one exception is a list, which is represented as a vector but can contain
objects of different classes(indeed, that’s usually why we use them)
Empty vectors can be created with the vector() function.

Numbers
 Numbers in R a generally treated as numeric objects(i.e. double precision real number)
 If you explicitly want an integer, you need to specify the L suffix.
 Ex: Entering 1 gives you a numeric object; entering 1L explicitly gives you an interger.
 There is also a special number Inf which represents infinity; e.g. 1/0 ; Inf can be used
in ordinary calculation
 The value NaN represents an undefined value(“not a number”); e.g. 0/0; NaN can also
be thought of as a missing value( more on that later)

Attributes
R objects can have attributes
 names, dimnames
 dimesions (e.g. matrices, arrays)
 calss
 length
 other user-defined attributes/metadata
Attributes of an object can be accessed using the attributes() function.

Entering Input
At the R prompt we type expressions. The <- symbol is the assignment
operator.
> x <- 1
> print(x)
The grammar of the language determines whether an expression is
complete or no.
> x <- ## Incomplete expression
The # character indicates a comments. Anything to the right of the
#(including the # itself) is ignored

Evaluation
When a complete expression is entered at the prompt, it is evaluated and
the result of the evaluated expression is returned. The result may be auto-printed
> x <- 5 ## nothing printed
> x ## auto-printing occurs
[1] 5
> print(x) ## explicit printing
[1] 5
The [1] indicates that x is a vector and 5 is the first element.

Printing
> x <- 1:20
> print(x)
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
The : operator is used to create integer sequences.

Creating Vectors
The c() function can be used to create vectors of objects.
> x <- (0.5, 0.6) ## numeric
> x <- c(TRUE, FALSE) ## logical
> x <- c(T,F) ## logical
> x <- c(“a”,”b”,”c”) ## character
> x <- 9:20 ## integer
> x <- c(1+0i, 2+4i) ## complex
Using the vector() function
> x <- vector(“numeric”, length =10)
> x
[1] 0 0 0 0 0 0 0 0 0 0

Mixing Objects
What about the following?
> x <- c(1.7, “a”) ## character
> x <- c(T,2) ## numeric
> x <- c(“a”,TRUE) ## character
When different objects are mixed in a vector, coercion occurs so that every
element in the vector is of the same class.

Explicit Coercion
Objects can be explicitly coerced from one class to another using as.*
functions
> x <- 0:6
> class(x)
[1] “integer”
> as.numeric(x)
[1] 0 1 2 3 4 5 6
> as.logical(x)
[1] FALSE TRUE TRUE TRUE TRUE TRUE TRUE
> as.character(x)
[1] “0” “1” “2” “3” “4” “5” “6”
> as.complex(x)
[1] 0+0i 1+0i 2+0i 3+0i 4+0i 5+0i 6+0i

Explicit Coercion
Nonsensical coercion result in NAS
> x <- c(“a”,”b”,”c”)
> class(x)
[1] “character”
> as.numeric(x)
[1] NA NA NA
Warning message:
NAs introduced by coercion
> as.logical(x)
[1] NA NA NA
> as.complex(x)

Matrices
Matrices are vectors with a dimension attribute. The dimension attribute is
itself an integer vector of length2(nrow, ncol)
> m <- matrix(nrow = 2, ncol =3)
> m
[,1] [,2] [,3]
[1,] NA NA NA
[2,] NA NA NA
> dim(m)
[1] 2 3
> attributes(m)
$dim
[1] 2 3

Matrices (constructed)
Matrices are constructed column-wise, so entries can be thought of starting
“upper left” corner and running down the columns.
> m <- matrix(1:6, nrow = 2, ncol =3)
> m
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6

Matrices (constructed)
Matrices can also be created directly from vectors by adding a dimension
attribute.
> m <- 1:10
> m
[1] 1 2 3 4 5 6 7 8 9 10
> dim(m) <- c(2,5)
> m
[,1] [,2] [,3] [,4] [,5]
[1,] 1 3 5 7 9
[2,] 2 4 6 8 10

cbind-ing and rbind-ing
Matrices can be created by column-binding or row-binding with cbind()
and rbind().
> x <- 1:3
> y <- 10:12
> cbind(x,y)
x y
[1,] 1 10
[2,] 2 11
[3,] 3 12
> rbind(x,y)
[,1] [,2] [,3]
x 1 2 3
y 10 11 12

Lists
Lists are a special type of vector that can contain elements of different
classes. Lists are a very important data type in R and you should get to
know them well.
> x <- list(1, “a”, TRUE, 1+4i)
> x
[[1]]
[1] 1
[[2]]
[1] "a"
[[3]]
[1] TRUE
[[4]]
[1] 1+4i

Factors
Factors are used to represented categorical data. Factors can be unordered
or ordered. One can think of a factor as an integer vector where each
integer has a label.
 Factors are treated specially by modeling function like lm() and glm()
 Using factors with labels is better than using integer because factors are self-describing
; having a variable that has values “Male” and “Female” is better than a
variable that has values 1 and 2.

Factors
> x <- factor(c(“yes”,”yes”,”no”,”yes”,”no”)
> x
[1] yes yes no yes no
Levels: no yes
> table(x)
x
no yes
2 3
> unclass(x)
[1] 2 2 1 2 1
attr(,"levels")
[1] "no" "yes"

Factors
The order of the levels can be set using the levels argument to factor(). This
can be important in linear modeling because the first level is used as the
baseline level.
> x <- factor(c(“yes”,”yes”,”no”,”yes”,”no”), levels = c(“yes”,”no”)
> x
[1] yes yes no yes no
Levels: yes no

Missing Values
Missing values are denoted by NA or NaN for undefined mathematical
operations.
 is.na() is used to test if they are NA
 is.nan() is used to test for NaN
 NA values have a class also, so there are integer NA, character NA, etc
 A NaN but the converse is not true.

Data Frames
Data frames are used to store tabular data
 They are represented as a special type of list where every element of the list has to
have the same length
 Each element of the list can be thought of as a column and the length of each
element of the list is the number of rows.
 Unlike matrices, data frames can store different classes of objects in each column (just
like lists); matrices must have every element be the same class.
 Data frames also have a special attribute called row.names
 Data frames are usually created by calling read.table() or read.csv()
 Can be converted to a matrix by calling data.matirx()

Data Frames
> x <- data.frame(foo=1:4, bar=c(T,T,F,F))
> x
foo bar
1 1 TRUE
2 2 TRUE
3 3 FALSE
4 4 FALSE

Names
R objects can also have names, which is very useful for writing readable
code and self-describing objects.
> x <- 1:3
> names(x)
NULL
> names(x) <- c(“foo”,”bar”,”norf”)
>x
foo bar norf
1 2 3
> names(x)
[1] "foo" "bar" "norf"

Names
Lists can also have names
> x <- list(a =1, b=2, c=3)
> x
$a
[1] 1
$b
[1] 2
$c
[1] 3

Names
And matrices
> m <- matrix(1:4, nrow=2)
> dimnames(m) <- list(c(“a”,”b”), c(“c”,”d”)
> m
c d
a 1 3
b 2 4

Summary
Data Types
 atomic classes: numeric, logical, character, integer, comples
 vectors, lists
 factors
 missing values
 data frames
 naems

Subsetting
There are a number of operators that can be used to extract subsets of R
objects.
 [ always returns an object of the same class as the original; can be used to select more
than one element.
 [[ is used to extract elements of a list or a data frame; it can only be used to extract a
single element and the class of the returned object will not necessarily be a list or
data frame.
 $ is used to extract elements of a list or data frame by name

Subsetting
> x <- list(a =1, b=2, c=3)
> x
$a
[1] 1
$b
[1] 2
$c
[1] 3

Subsetting a Matrix
Matrices can be subsetting in the usual way with (i,j) type indices .
> x <- matrix(1:6, 2,3)
> x[1,2]
[1] 3
Indices can also be missing.
> x[1,]
[1] 1 3 5
> x[,1]
[1] 1 2

Subsetting a Matrix
By default, when a single element of a matrix retrieved, it is returned as a
vector of length 1 rather than a 1X1 matrix. This behavior can be turned off
by setting drop = FALSE.
> x <- matrix(1:6, 2,3)
> x[1,2]
[1] 3
> x[1,2, drop =FALSE]
[,1]
[1,] 3

Subsetting a Matrix
Similarly, subsetting a single column or a single row will give you a vector,
not a matrix(by default)
> x <- matrix(1:6, 2,3)
> x[1,]
[1] 1 3 5
> x[1, , drop =FALSE]
[,1] [,2] [,3]
[1,] 1 3 5

Subsetting Lists
> x <- list(foo=1:4, bar=0.6)
> x[1]
$foo
[1] 1 2 3 4
> x[[1]]
[1] 1 2 3 4

Subsetting Lists
> x <- list(foo = 1:4, bar = 0.6, baz=“hello”)
> x[c(1,3)]
$foo
[1] 1 2 3 4
$baz
[1] “hello”

Subsetting Lists
The [[ operator can be used with computed indices; $ can only be used
literal names.
> x <- list(foo = 1:4, bar = 0.6, baz = “hello”)
> name <- “foo”
> x[[name]]
[1] 1 2 3 4
> x$foo
[1] 1 2 3 4

Subsetting Nested Elements of a List
The [[ can take an integer sequence.
> x <- list (a = list(10,12,14), b= c(3.14, 2.81))
> x[[c(1,3)]]
[1] 14
> x[[1],[3]]
[1] 14

Partial Matching
Partial matching of names is allowed with [[ and $.
> x <- list(aardvark = 1:5)
> x$a
[1] 1 2 3 4 5
> x[[“a”]]
NULL
> x[[“a”, exact=FALSE]]
[1] 1 2 3 4 5

Removing NA Values
A common task is to remove missing values(NAS).
> x <- c(1,2,NA,4,NA,5)
> bad <- is.na(x)
> x[!bad]
[1] 1 2 4 5

Removing NA Values
What if there are multiple things and you want to take the subset with no
missing values?
> x <- c(1,2,NA,4,NA,5)
> y <- c(“a”,”b”,NA,”d”,NA,”f”)
> good <- complete.cases(x,y)
> good
[1] TRUE TRUE FALSE TRUE FALSE TRUE
> x[good]
> y[good]

Removing NA Values
What if there are multiple things and you want to take the subset with no
missing values?
> airquality[1:6,]
Ozone Solar.R Wind Temp Month Day
1 41 190 7.4 67 5 1
2 36 118 8.0 72 5 2
3 12 149 12.6 74 5 3
4 18 313 11.5 62 5 4
5 NA NA 14.3 56 5 5
6 28 NA 14.9 66 5 6
> good <- complete.cases(airquality)

Removing NA Values
> airquality[good,][1:6,]
Ozone Solar.R Wind Temp Month Day
1 41 190 7.4 67 5 1
2 36 118 8.0 72 5 2
3 12 149 12.6 74 5 3
4 18 313 11.5 62 5 4
7 23 299 8.6 65 5 7
8 19 99 13.8 59 5 8

Reading Data
There are a few principal function reading data into R
 read.table, read.csv, for reading tabular data
 readLines, for reading lines of a text file
 source, for reading in R code files(inverse of dump)
 dget, for reading in R code files(inverse of dput)
 load, for reading in saved workspaces
 unserialize, for reading R objects in binary form

Writing Data
There are analogue functions for writing data files
 write.table
 writeLines
 dump
 dput
 save
 serialize

Reading Data files with read.table
The read.table function is one of the most commonly used function for
reading data. It has a important arguments.
 file, the name of file, or a connection
 header, logical indicating if the file has a header line
 sep, a string indicating how the columns has separate
 colClasses, a character vector indicating the class of each colum in the data set
 nrows, the number of rows in the data set
 comment.char, a character string indicating the comment character
 skip, the number of lines to skip from the beginning
 stringsAsFactors, should character variables be coded as factor?

read.table
For small to moderately sized datasets, you con usually call read.table
without specifying any arguments.
data <- read.table(‘foo.txt’)
data <- read.table(“foo.txt”)
R will automatically
 skip lines that begin with a#
 figure out how many rows there are (and how much memory needs to be allocated)
 figure what type of variable is in each column of the table Telling R all these directly
makes faster and more efficiently
 read.csv is identical to read.table except that the default separator is a comma.

Reading in Larger Datasets with read.table
With much larger datasets, doing the following things will makes your life
easier and will prevent R from choking
 Read the help page for read.table, which contains many hints
 Make a rough calculation of the memory required to store your dataset. If the dataset
is larger than the amount of RAM on your computer, you can probably stop right here.
 Set comment.char = “” if there are no commented lines in your file.

Reading in Larger Datasets with read.table
Use the colClasses argument. Specifying this option instead of using the
default can make ‘read.table’ run MUCH faster, often twice as as fast. In
order to use this option, you have to know the class of each column in
your data frame. If all of the columns are “numeric”, for example, then you
can just set colClasses = “numeric”. A quick an dirty way to figure out the
classes of each column is the following:
initial <- read.table(‘datatable.txt’, nrows = 100)
classes <- sapply(initial, class)
tabAll <- read.table(‘datatable.txt’, colClasses = classes)
 Set nrows. This doesn’t make R run faster but it helps with memory usage. A mild
overestimate is okay. You can use the Unix tool wc to calculate the number of lines in
a file.

Know Thy System
In general, when using R with larger datasets, it’s useful to know a few
thing about your system.
 How much memory is available?
 What other applications are in use?
 Are there other users logged into the same system?
 What operating system?
 Is the OS 32 or 64 bit?

Calculating Memory Requirements
I have a data frame with 1,500,000 rows and 120 columns, all of which are
numeric data. Roughly how much memory is required to store this data
fame?
 1,500,000 X 120 X 8 bytes/numeric
= 1440000000 bytes
= 1440000000 / 2**20 bytes/MB
= 1,373.29 MB
= 1.34 GB

Textual Format
 Dumping and dputing are useful because the resulting textual format is edit-able, and
in the case of corruption, potentially recoverable.
 Unlike writing out a table or csv file, dump and dput preserve the metadata(sacrificing
some readablity), so that another user doesn’t have to specify it all over again.
 Textual formats can work much better with version control programs like subversion or
git which can only track changes meaningfully in text files.
 Textual formats can be longer-lived; if there is corruption somewhere in the file, it can
be easier to fix the proplem.
 Textual formats adhere to the “Unix philosophy”
 Downside: The format is not very space-efficient

Dput-ting R Objects
Another way to pass data around is by deparsing the R object with dput
and reading it back in using dget.
>y <- data.frame(a=1, b=“a”)
>dput(y)
structure(list(a=1,
b=structure(1L, .Label = ‘a’,
class=‘factor’)),
.Names=c(‘a’,’b’), row.names = c(NA, -1L),
class = ‘data.frame’)
>dput(y, file = “y.R”)
>new.y <- dget(“y.R”)
>new.y

Dumping R Objects
Multiple objects can be deparsed using dump function and read back in
using source
>x <- “foo”
>y <- data.frame(a=1, b=“a”)
>dump(c(“x”,”y”), file = “data.R”)
>rm(x,y)
>source(“data.R”)

Interfaces to the Outside Worl
Data are read in using connection interface. Connections can be made to
file(most common) or to other more exotic thing.
 file, opens a connection to a file
 gzfile, opens a connection to a file compressed with gzip
 bzfile, opens a connection to a file compressed with bzip2
 url, opens a connection to a webpage

File connections
>str(file)
function (description = "", open = "", blocking = TRUE, encoding =
getOption("encoding"), raw = FALSE)
 description is the name of the file
 open is a code indicating
- “r” read only
- “w” writing(and initializing a new file)
- “a” appending
- “rb”, “wb”, “ab” reading, writing, or appending in binary mode(Winddows)

Connections
In general, connections are powerful tools that let you navigate files or
other external objects. In practice, we often don’t need to deal with the
connection interface directly.
>con <- file(“foo.txt”,”r”)
>data <- read.csv(con)
>close(con)
is the same as
>data <- read.csv(“foo.txt”)

Reading Lines of a Text File
Sometimes connection can be very userful.
>con <- gzfile(“words.gz”)
>x <- readLines(con,10)
>x
writeLines takes a character vector and write each element one line at a
time to a text file

Reading Lines of a Text File
readLines can be useful for reading in lines of webpages
> con <- url("http://jhsph.edu","r")
> x <- readLines(con)
> head(x)
[1] "<!DOCTYPE html>"
[2] "<html lang="en">"
[3] ""
[4] "<head>"
[5] "<meta charset="utf-8" />"
[6] "<title>Johns Hopkins Bloomberg School of Public Health</title>"

Control Structures
Control structures in R allow you to control the flow of execution of the
program, depending on runtime conditions. Common structures are
 if, else : testing a conditon
 for : execute a loop a fixed number of times
 while : execute a loop while a condition is true
 repeat : execute an infinite loop
 break : break the execution of a loop
 next : skip an alteration of a loop
 return : exit a function
Most control structure are not used in interactive sessions, but rather when
functions or longer expressions.

Control Structures: if
if(<condition>){
## do something
} else {
## do something else
}
>if(<condition1>){
## do something
} else if(<condition2>){
## do something different
} else {
## do something different
}

if
This is a valid if/else structure
if(x >3) {
y <- 10
} else {
y <- 0
}
So is the one
y <- if(x >3){
} else {
0
}

for
for loops take an iterator variable and assign it successive values from a
sequence or vector. For loops are most commonly used for iterating over
the elements of and object(list, vector, etc.)
for(i in 1:10){
print(i)
}
This loop takes the i variable in each iteration of the loop gives it values
1,2,3,..., 10, and then exits.

for
These three loops have the same behavior.
>x <- c(“a”,”b”,”c”,”d”)
for(i in 1:4) {
print(x[i])
}
for(i in seq_along(x)) {
print(x[i])
}
for(letter in x) {
print(letter)
}
for(i in 1:4) print(x[i])

Nested for loops
for loops can be nested
>x <- matrix(1:6, 2, 3)
for(i in seq_len(nrow(x))) {
for( j in seq_len(ncol(x))) {
print(x[i,j])
}
}
Be careful with nesting though. Nesting beyond 2-3 levels is often very
difficult to read/understand.

while
While loops begin by testing a condition. if is true, then they execute the
loop body is executed, the condition is tested again, and so forth.
count <- 0
whiel(count <10) {
print(count)
count <- count +1
}
While loops can potentially result in infinite loops if not written properly.
Use with care!

while
Sometimes there will be more than one condition in the test
> z <- 5
while(z >=3 && z <= 10){
print(z)
coin <- rbinom(1, 1, 0.5)
if(coin == 1){ ## random walk
z <- z+1
} else {
z <- z-1
}
}
Conditions are always evaluated from left to right.

repeat
Repeat initiate an infinite loop; these are not commonly used in statistical
applications but they do have their uses. The only way to exit a repeat loop
is to call break.
x0 <- 1
tol <- 1e-8
repeat {
x1 <- computeEstimate()
if(abs(x1 – x0) < tol) {
break
} else {
x0 <- x1
}
}

Funtions
Functions are created using the function() directive and are stored as R
objects just like anything else. In particular, they are R objects of class
“Function”
f <- function(<arguments>) {
## do something interesting
}
Functions in R are “first class objects”, which means that they can be
treated much like any other R object. Importantly.
 Functions can be passed as arguments to other functions.
 Functions can be nested, so that you can define inside of another function. The return
value of a function is the last expression in the function body to be evaluated.

Function Arguments
Functions have named arguments which potentially have default values.
 The formal arguments are the arguments included in the function definition.
 The formals function returns a list of all the formal arguments of a function.
 Not every function call in R makes use of all formal arguments.
 Function arguments can be missing or might have default values.

Argument Matching
R function arguments can be matched positionally or by mane. So the
following calls to sd are all equivalent.
>mydata <- rnorm(100)
>sd(mydata)
>sd(x = mydata)
>sd(x = mydata, na.rm=FALSE)
>sd(na.rm=FALSE, x=mydata)
>sd(na.rm=FALSE, mydata)
Even though it’s legal, I don’t recommend messing around with order of
the arguments too much, since it can lead to some confusion.

Argument Matching
You can mix positional matching with matching by name. When an
argument is matched by name, it is “taken out” of the argument list and
the remaining unnamed arguments are matched in the order that they are
listed in the function definition.
>args(lm)
function (formula, data, subset, weights, na.action, method = "qr", model = TRUE, x =
FALSE, y = FALSE, qr = TRUE, singular.ok = TRUE, contrasts = NULL, offset, ...)
The following two calls are equivalent
lm(data = mydata, y-x, model = =FALSE, 1:100)
lm(y-x, mydata, 1:100, model = FALSE)

Argument Matching
 Most of the time, named arguments are useful on the command line when you have a
long argument list and you want to use the defaults for everything except for an
argument near the end of the list.
 Named arguments also help if you can remember the name of the argument and not
its position on the argument list(plotting is a good example)

Argument Matching
Function arguments can also be partially matched, which is useful for
interactive work. The order of operations when given an argument is
1. Check for exact match for a named argument
2. Check for a partial match
3. Check for a positional match

Lazy Evaluation
Arguments to functions are evaluated lazily, so they are evaluated only as
needed
f <- function(a, b){
a^2
}
f(2)
##[1] 4
This function never actually uses the argument b, so calling f(2) will not
produce an error because the 2 gets positionally matched to a.

Lazy Evaluation
f <- function(a, b){
print(a)
print(b)
}
f(45)
##[1] 45
##Error : argument “b” is missing, with no deault
Notice that “45” got printed the error was triggered. This is because b did
not have to be evaluated until after print(a). Once the function tried to
evaluate print(b) it had to throw an erro.

The “...” Argument
The ... argument indicate a variable number of arguments that are usually
passed on to other functions.
 ... is often used when extending another function and you don’t want to copy the
entire argument list of the original function
myplot <- function(x, y, type = “1”, ...){
plot(x, y, type, ...)
}
 Generic functions use ... so that extra arguments can be passed to methods(more on
this later)
>mean
function (x, ...)
UseMethod("mean")

The “...” Argument
The ... argument is also necessary when the number of arguments passed
to the function cannot be known in advance
>args(paste)
function (..., sep = " ", collapse = NULL)
>args(cat)
function (..., file = "", sep = " ", fill = FALSE, labels = NULL, append = FALSE)

Arguments Coming After the “...” Argument
Once catch with ... is that any arguments that appear after ... on the
argument list must be named explicitly and cannot be partially matched.
>args(paste)
function (..., sep = " ", collapse = NULL)
>paste(“a”,”b”,sep=“:”)
[1] "a:b"...,
>paste(“a”,”b”,se=“:”)
[1] "a b :"

A Diversion on Binding Values to Symbol
How does R know which value to assign to which symbol? When I type
>lm <- function(x){ x * x }
>lm
function(x) { x * x }
How does R know what value to assign to the symbol lm? Why doesn’t it
give it the value of lm that is in the stats package?

A Diversion on Binding Values to Symbol
When R tries to bind a value to a symbol, it searches through a seriese of
environments to find the appropriate value. When you are working on the
command line and need to retrieve the value of R object, the order is
roughly.
1. Search the global environment for a symbol name matching the one requested.
2. Search the namespaces of each the packages on the search list.
The search list can be found by using the search function.
>search()
[1] ".GlobalEnv" "package:maptools" "package:sp" "package:ggplot2" [5] "tools:rstudio"
"package:stats" "package:graphics" "package:grDevices" [9] "package:utils"
"package:datasets" "package:methods" "Autoloads" [13] "package:base"

Binding Values to Symbol
 The global environment or the user’s workspace is always the first element of the
search list and the base package is always the last.
 The order of the packages on the search list matters!
 User’s can configure which packages get loaded on startup so you cannot assume that
there will be a set list of packages available.
 When a user loads a package with library the namespace of that package get put in
position 2 of the search list(by default) and everything else gets shifted down the list.
 Note that R has separate namespaces for functions and non-functions so it’s possible
to have an object named c and a function c.

Scoping Rules
The scoping rules for R are the main feature that make it different from the
original S language.
 The scoping rules determine how a value is associate with a free variable in a function.
 R uses lexical scoping or static scoping. A common alternative is dynamic scoping.
 Related to the scoping rules is how R uses the search list to bind a value to a symbol.
 Lexical scoping turns out to be particularly useful for simplifying statistical
computations.

Lexical Scoping
Consider the following function.
f <- function(x,y) {
x^2 + y /z
}
This function has 2 formal arguments x and y. In the body of the function
there is another symbol z. In this case z is called a free variable. The
scoping rules of a language determine how values are assigned to free
variables. Free variables are not formal arguments and are not local
variables(assigned inside the function body).

Lexical Scoping
Lexical scoping in R means that
the values of free variables are searched in the environment in which the
function was defined.
What is an environment?
 An environment is a collection of (symbol, value) pairs, i.e. x is a symbol and 3.14
might be its value.
 Every environment has a parent environment; it is possible for an environment to have
multiple “children”.
 The only environment without a parent is the empty environment.
 A function + an environment = a closure or function closure.

Lexical Scoping
Searching for the value for a free variable:
 If the value of a symbol is not found in the environment in which a function was
defined, then the search is continued in the parent environment.
 The search continues down the sequence of parent environments until we hit the top-level
environment; this usually the global environment(workspace) or the namespace
of a package.
 After the top-level environment, the search continues down the search list until we hit
the empty environment. If a value for a given symbol cannot be found once the empty
environment is arrived at, then an error is thrown.

Lexical Scoping
Why does all this matter?
 Typically, a function is defined in the global environment, so that the value of free
variables are just found in the user’s workspace.
 This behavior is logical for most people and is usually the “right thing” to do.
 However, in R you can have functions defined inside other functions
- Languages like C don’t let you do this
 Now things get interesting – In this case the environment in which a function is
defined is the body of another function!

Lexical Scoping
make.power <- function(n){
pow <- function(x){
x^n
}
pow
}
This function returns another function as its value
>cube <- make.power(3)
>square <- make.power(2)
>cube(3)
[1] 27
>square(3)
[1] 9

Exploring a Function Closure
What’s in a function’s environment?
>ls(environment(cube))
[1] "n" "pow"
>get(“n”, environment(cube))
[1] 3
>ls(environment(square))
[1] "n" "pow"
>get(“n”, environment(square))
[1] 2

Lexical vs. Dynamic Scoping
y <- 10
f <- function(x) {
y <- 2
y^2+g(x)
}
g <- function(x) {
x*y
}
What is the value of
f(3)

 With lexical scoping the value of y in the function g is looked up in the environment
in which the function was defined, in this case the global environment, so the value of
y is 10.
 With dynamic scoping, the value of y is looked up in the environment from which the
function was called(sometimes referred to as the calling environment).
- In R the calling environment is known as the parent frame.
 So the value of y would be 2.

When a function is defined in the global environment and is subsequently
called from the global environment and the calling environment are the
same. This can sometimes give the appearance of dynamic scoping.
>g <- function(x){
a<-3
x+a+y
}
>g(2)
Error in g(2) : object 'y' not found
>y <- 3
>g(2)
[1] 8

Consequence of Lexical Scoping
 In R, all objects must be stored in memory.
 All functions must carry a point to their respective defining environments, which could
be anywhere.
 In S-PLUS, free variables are always looked up in the global workspace, so everything
can be stored on the disk because the “defining environment” of all function is the
same.

Vectorized Operations
Many operations in R are vectorized making code more efficient, concise,
and easier to read.
>x <- 1:4; y <- 6:9
>x+y
[1] 7 9 11 13
>x > 2
[1] FALSE FALSE TRUE TRUE
>y == 8
[1] FALSE FALSE TRUE FALSE
>x*y
[1] 6 14 24 36

Vectorized Matrix Operations
>x <- matrix(1:4,2,2); y <- matrix(rep(10,4),2,2)
>x*y ## element-wise multiplication
[,1] [,2]
[1,] 10 30
[2,] 20 40
>x %* % y ## true matrix multiplication
[,1] [,2]
[1,] 40 40
[2,] 60 60

Dates and Times in R
R has developed a special representation of dates and times
 Dates are represented by the Date class.
 Times are represented by the POSIXct or the POSIXlt class.
 Dates are stored internally as the number of days since 1970-01-01
 Times are stored internally as the number of seconds since 1970-01-01

Dates in R
Dates are represented by the Date class and be coerced from a character
string using the as.Date() function.
>x <- as.Date(“1970-01-01”)
x
##[1] “1970-01-01”
unclass(x)
## [1] 0
unclass(as.Date(“1970-01-02”))
## [1] 1

Times in R
Times are represented using the POSIXct or the POSIXlt class
 POSIXct is just a very large integer under the hood; it use a useful class when you
want to store times in something like a data frame.
 POSIXlt is a list underneath and it stores a bunch of other useful information like the
day of the week, day of the year, month, day of the month.
There are number of generic functions that work on dates and times
 weekdays : give the day of the week
 months : give the month name
 quarters : give the quarter number(“Q1”,”Q2”,”Q3”,or”Q4”)

Times in R
Times can be coerced from a character string using the as.POSIXlt or
as.POSIXct function.
>x <- Sys.time()
x
p <- as.POSIXlt(x)
names(unclass(p))
[1] "sec" "min" "hour" "mday" "mon" "year" "wday" "yday" "isdst" "zone" "gmtoff"
p$min

Times in R
You can also use the POSIXct format.
>x <- Sys.time()
x ## Already in ‘POSIXct’ format
unclass(x)
x$min p
p <- as.POSIXlt(x)
p$min

Times in R
Finally, there is the strptime function in case your dates are written in a
different format.
datestring <- c(“January 10, 2012 10:40”, “December 9, 2011 9:10”)
x <- strptime(datestring, “%B %d, %Y %H:%M”)
x
class(x)

Operations on Dates and Times
You can use mathematical operations on dates and times. Well, really just+
and -. You can do comparisons too(i.e. ==, <=)
x <- as.Date(“2014-01-01”)
y <- strptime(“9 Jan 2011 11:34:21”, %d %b %Y %H:%M:%S”)
x-y
x <- as.POSIXlt(x)
x-y

Operations on Dates and Times
Even keeps track of leap years, leap seconds, daylight savings, and time
zones.
x <- as.Date(“2014-03-01”) y <- as.Date(“2014-02-28”)
x-y
x <- as.POSIXct(“2012-10-25 01:00:00”)
y <- as.POSIXct(“2012-10-25 06:00:00”, tz = “GMT”)
x-y

Summary
 Dates and times have special classes in R that allow for numerical and statistical
calculations.
 Dates use the Date class
 Times use the POSIXct and POSIXlt class
 Character strings can be coerced to Date/Time classes using the strptime function or
the as.Date, as.POSIXlt or as.POSIXct

Looping on the Command Line
Writing for, while loops is useful when programming but not particularly
easy when working interactively on the command line. There are some
functions which implement looping to make life easier.
 lapply : Loop over a list and evaluate a function on each element
 sapply : Same as lapply but try to simplify the result
 apply : Apply a function over the margins of an array
 tapply : Apply a function over subsets of a vector
 mapply : Multivariate version of lapply
An auxiliary function split is also useful, particularly in conjunction with
lapply.

lapply
lapply takes three arguemnts : (1) a list x; (2) a function (or the name of a
function) FUN; (3) other arguments via its ... argument. If x is not a list, it
will be coerced to a list using as.list.
lapply
function (X, FUN, ...)
{ FUN <- match.fun(FUN)
if (!is.vector(X) || is.object(X))
X <- as.list(X) .Internal(lapply(X, FUN))
}
<bytecode: 0x0000000009c2b038>
<environment: namespace:base>
The actual looping is done internally in C code.

lapply
lapply always returns a list, regardless of the class of the input.
> x <- list(a = 1:5, b=rnorm(10))
> lapply(x, mean)
$a
$b

R교육1

More Related Content

What's hot (20)

Similar to R교육1 (20)

More from Kangwook Lee (20)

R교육1