R Language

• library() see the list of installed packages.
• library(class) load the package class.
• search() see the list of loaded packages.
• install.packages() and update.packages() install and update packages.

If a library is "not available", you probably should add the repository:

• setRepositories() and select something like bioc* or R-Forge. If that still doesn't work, you can download and install from source:

install.packages("/path/to/file.tar.gz", repos=NULL)

But seems that you need to install the dependencies manually.

To start ESS session, run command S. ESS will create a command interface as a buffer. Execute ?foo will open the R-doc for the function foo.

There's a babel in org mode for R, so just C-c C-c would work. This will prompt to create a session. One special for this babel is you can evaluate by line, using C-<RET> in the edit buffer.

Keep the session using the header:

#+PROPERTY: session *R*

To export a graph:

:file image.png :results output graphics :exports both

To export ordinary result:

:exports both

To export some summary data:

:exports both :results output org

We need to know what's going on in the current workspace. getwd() and setwd() get and set the current dir. ls() list the objects currently stored. rm(x, y, z) remove objects rm(list=ls()) remove all objects. objects() create and store current objects.

We can perform some IO by save.image("mydata.Rdata") and load("mydata.Rdata") will save and load workspace in current directory respectively. source("a.R") loads a script. sink("a.lis") redirects the output to a file, and sink() restore that to standard output.

You can view documentation by calling help help(lm). ?lm and ??solve also shows documentation, while example(topic), as its name indicates, shows the examples. help.start() opens the html documentation page.

Finally, q() quit R.

The print function can output the value of a variable.

print("hello")
cat("world", "!", "\n")
print(c(1,2,3))

To enter the debugger, a call to browser function suffices. This allows you to browse the values at that point. A more powerful debugger is by a call to debug with the function name as argument. Each time that function is called, you enter the debug and can control the execution. Tracing can be registered by trace or untrace with the name of the function. It might need to be quoted in some case, so you'd better quote it, with double quotes. Every time the function is invoked, the return value will be printed as trace.

• str show the structure of arbitrary type
• summary print the summary

To see the data, you can use:

• dim()
• length()
• head()
• tail()
• summary(dataset) shows some information like max,min,mean
• class(data$col) get type
• levels(data$col) if it is factor, get the values
• stopifnot(): the assert

Looks like all numbers are double by default:

typeof(1)
typeof(1L)

Create a vector by c(), which is append:

c(1,2,3)
x <- c(1,2,3)
c(x, 0, x)

Vectors are the array of objects of the same mode (type).

c(1, "hello")

To create a sequence:

1:10
10:1

Colon operator has higher priority:

2*1:10

The more powerful sequence function is seq:

seq(1,10)
seq(-1, 1, by=.2)
seq(length=10, from=-5, by=.2)

Repeating something:

x <- c(1,2,3)
rep(x, times=3)
rep(x, each=3)

The length, mode, typeof

x <- c(1,2,3)
length(x)
mode(x)
typeof(x)

Vectors can be indexed by integers, starting from 1.

x <- c(1,2,3,4)
x[2]

It can also be indexed by vector of integers

x <- c(1,2,3,4)
x[c(1,3)]

Negative index selects the elements other than those index. The index 0 will return empty (HEBI: ??).

x <- c(1,2,3,4)
x[0]
x[-1]
x[c(-1, -3)]

Indexing by logical vector

x <- c(1,2,3,4)
x[c(TRUE, FALSE, TRUE, FALSE)]

Or by its name, where the string is compared partially (HEBI: ??)

x <- c(1,2,3)
names(x) <- c("hello", "world", "lala")
x
x["hel"]
x["hello"]
x[c("hello", "world")]

This is to combine (for matrix, similar to append for vector) arguments in row-wise or column-wise, and creates matrix. This will apply broadcast.

cbind(0, rbind(1, 1:3))

Matrix can be created by the matrix function.

x <- matrix(1:8, nrow=2)
x
dim(x)

Specify dimnames:

matrix(1:6, nrow = 2, dimnames = list(c("a", "b"), LETTERS[1:3]))

When indexing, the drop argument (defaulting to TRUE), if TRUE, the result is coerced to the lowest possible dimension:

m <- matrix(1:6, nrow = 2, dimnames = list(c("a", "b"), LETTERS[1:3]))
m[1,]
m[1, , drop = FALSE]

list is a misnomer, it is a dict

l <- list(hello=1, "world"=2)
l
l$hello
l$world

When indexing lists, [] retains names, while [[]] returns only the element:

c(abc = 123)[1]

c(abc = 123)[[1]]

na.omit

can omit the NA values in data frame

A data frame is a list of equal-length vectors. When getting the data from read.csv, the result is a data frame. Use names to work on data frames will emit the names.

• Since it is a list, using [] to index will give also the list, a.k.a. data frame, retaining names. You can use a vector as index.
• Using [[]] to index will give the value, dropping names. You cannot use a vector as index.

you can change a type of a vector by

• as.factor(x)
• as.numeric()

• read.csv
• write
• write.table
• write.csv
• read.table("filename", header=TRUE, sep=",")
  • this ignores blank lines,
  • and expect the header to be one field less than the body.
  • # as comments
• read.delim
• cat outputs the data, no index, no newline

• attach(data): make the columns into this namespace
• detach(data): remove those

The missing values are NA, tested by is.na. Illegal computations produces NaN, e.g. 0/0.

subset

substr

• recycling rules: the shortest list is recycled to the length of longest.
• dimensional attributes: the dimension of matrix must match. No recycle for a matrix.

• if: if (STMT) STMT else if (STMT) STMT else STMT

The switch is quite interesting. It is

switch(x, list...)

The semantic is to find x in the list and return the value. If x is not in list, return NULL.

An unnamed list has implicit index as name:

switch(2,1,2,3)

Using name:

switch("hello", hello=1, world=2)

not found, return NULL:

is.null(switch("nothing", hello=1))

Interestingly, even for named list, we can still use the index:

switch(2, hello=1, world=2)

• for loop: for (NAME in VECTOR) STMT
• while loop: while (STMT) STMT
• repeat: repeat STMT
• break, next

ret <- c()
for (i in 1:5) {
  ret <- c(ret, i)
}
ret

A linear model is created and fitted by lm() function, with the model formula and data frame. For example:

df = data.frame(x=c(1,2,3), y=c(2,4,6))
fm = lm(y ~ x, data=df)
summary(fm)

The fitted model in the variable fm can be accessed by:

• coef: extract the coefficients
• deviance: the Residual Sum of Square
• formula: extract the model formula
• plot: produce four plots: residuals, fitted values, diagnostics.
• predict(OBJECT, newdata=DATA.FRAME): use the model to predict
• residuals: extract the residuals
• summary()

The models can be updated, if the formula only changes a little bit. In the following example, the . means the corresponding part of the original formula.

fs <- lm(y ~ x1 + x2, data=mydf)
fs <- update(fs, . ~ . + x3)
fs <- update(fs, sqrt(.) ~ .)

• box
• axis
• las attribute
• legend
• par
• text
• mtext
• points

When outputting some image, you have to tell R which format you want to use. The default on linux is X11, that's why it opens a image immediately after plotting. To use a device, call the device function, and after that all graphics output will be sent to that device.

• X11
• pdf
• png

• jpeg

  When you have finished with a device, terminate it by dev.off().

  To output to a file TODO to open plot in emacs:

    pdf("test1.pdf")
    dev.control(displaylist = "enable")
    plot(1:10)
    dev.copy(pdf, "test2.pdf")
    dev.off()
    # should now have a valid test2.pdf
    dev.off() # finished
  

Possible ... arguments:

• type what type of plot:
  • p for points,
  • l for lines,
  • b for both,
  • h for histogram like (or high-density) vertical lines,
• main an overall title for the plot: see title.
• xlab a title for the x axis: see title.
• ylab a title for the y axis: see title.

A Grammar of Data Manipulation

• cran page