# Common Tasks in R

## Installation, Configuration and Environment

.libPaths() displays the location of package libraries

## Vectors and Matrices

base::rep() replicates elements of vectors and lists.

rep(5, 3) #returns 5, 5, 5
rep(c(1,2),2) #returns 1 2 1 2
rep(c(1, 2), each=2) #returns 1 1 2 2
rep(1:3, 3:1) # 1, 1, 1, 2, 2, 3

base::seq() generates regular sequences. Very flexible with many options. Typical usage includes seq(from, to), seq(from, to, by= ), seq(from, to, length.out= ), seq(along.with= ), seq(from), seq(length.out= ).

seq(0, 1, length.out=11)
seq(stats::rnorm(20))
seq(1, 9, by = 2) # match
seq(1, 9, by = pi)# stay below
seq(1, 6, by = 3)
seq(1.575, 5.125, by=0.05)
seq(17) # same as 1:17

base::vector() produces a vector of the given length and mode. The atomic modes are ‘logical’, ‘integer’, ‘numeric’, ‘complex’, ‘character’ and ‘raw’. Mode can also be ‘list’

X = vector(mode=’list’, length=10000) #creates list with 10000 cells of NULL
X = vector(mode=’numeric’, length = 5) #creates numeric vector of 5 zeros

base::matrix() creates a 2d matrix (see also base::array) X= matrix(data = NA, nrow=2,ncol=2, dimnames = list(c(‘row1’, ‘row2’), c(‘col1’, ‘col2’))) # creates empty 2X2 matrix

## Generic Variable Manipulation

### Calculate new variable within subjects (e.g., standardize startle within subject)

Use the plyr package. In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. There is a year variable which indicates the calendar year (e.g. 1991) for each row. To transform calendar year to career year (cyear; i.e. the number of years since the player started playing), for each player, do the following:

baseball = ddply(.data= baseball, .variables= c(‘id’), .fun= transform, cyear = year – min(year) + 1)

NOTES: transform() is a function in base R. id is a unique identifier (e.g., SubID) for each baseball player. More detail on this example can be found in the published article on plyr from the plyr website

## Factor Manipulation

### Create a factor

base::factor() creates a factor variable from text or numeric variable

d\$AFactor = factor(d\$BevGroup, levels = c(‘no-alcohol’, ‘placebo’, ‘alcohol’)) #create factor AFactor from variable with text data labels
d\$AFactor = factor(d\$BevGroup, levels = c(1,2,3), labels = c(‘no-alcohol’, ‘placebo’, ‘alcohol’)) #create factor AFactor from variable with numeric entries 1=no-alcohol, 2=placebo, 3=alcohol

### Display levels of a factor

base::levels() sets or displays the levels of a factor.

levels(BevGroup) #displays the levels the BevGroup factor
levels(BevGroup) = c(‘no-alcohol’, ‘placebo’, ‘alcohol’) #set levels of BevGroup as indicated. NOTE: this is not recommended because it is error prone, use revalue()

### Changle labels of factor levels

plyr::revalue() changes the values of specific levels of the factor, without respect to their order

d\$BevGroup = revalue(d\$BevGroup, c(“Alcohol”=”Alc”, “No-Alcohol”=”NoAlc”))

## Date/Time Manipulations

use as.POSIXct() to convert text date to a POSIXct calendar date. This allows for standard use of a date object.

Date = ’10/12/2016 14:32:10′ #timezone is ‘America/Chicago’ which determines CST and CDT by date but probably presents a problem for the ambiguous times during switch days

(t=as.POSIXct(x=Date, format=’%m/%d/%Y %H:%M:%S’, tz = “America/Chicago”))

Info on specification of format string can be found in strptime()

To change a POSIXct date object to an integer (i.e. unix timestamp)

as.numeric(t)

To see the attributes of a POSIXct date object

attributes(t)

To change the timezone of a POSIXct date object (for display only. It doesnt fundamentally change the date/time. It is still the same moment in time)

attributes(t)\$tzone = ‘UTC’

Note that it doesnt change the date itself, it just changes how it is displayed. e.g. Unix time stamp is unchanged by timezone change as.numeric(t)

If you want to force the time zone to change without updating the time use force_tz from the lubridate package. Note that this will change the moment in time but can be useful when functions default to giving you UTC but your input was in another time zone (like converting from excel)

NewTime = force_tz(OldTime, tz=’America/Chicago’)

This wikipedia page is useful for finding valid timezone info

The Epoch Converter is also a useful web resource

## Using Dataframes

### Opening dataframes from various sources

lmSupport::lm.readDat() loads tab delimited text in Curtin lab format

d = lm.readDat (‘Data.dat)
d = lm.readDat(‘Data.dat’, SubID = ‘ID’)

d= read.table(‘clipboard’, header=TRUE) #read data via the clipboard (e.g., from Excel)

base::scan() allows input from keyboard directly into a data frame. Separate entries by space. Enter a blank line to terminate input.

dData = scan()

R.matlab::readMat() and writeMat() are used to read and write Matlab MAT files.

d= data.frame(d)

base::file.choose() is used to bring up dialog box to select filename and path

clipboard is used in various functions to read from clipboard rather than file.
d = read.delim(‘clipboard’) after copying excel data to clipboard.

### Creating a new dataframe

base::data.frame() creates a dataframe from vectors

d= data.frame(X=seq(2,10,2), Y=(1:5), Z=c(1,3,6,10,12))#define vectors named X, Y, and Z
d= data.frame(BevGroup, Sex, Age) #use previously defined vectors.

### Saving dataframe

lmSupport::lm.writeDat() writes a data frame to tab-delimited text file using Curtin lab defaults

lm.writeDat(d, ‘Data.dat’)

utils::write.table() writes a dataframe to a text file.

write.table(d,file=’c:\\Data.dat’, sep=’\t’) #use sep = ‘\t’ to write as tab-delimited (non-default option)
write.table(d,file=’c:\\Data.dat’, sep=’\t’, row.names=FALSE) #use row.names=FALSE to not write case/row.names (i.e., if you want to use data later in SPSS)

### Display data and properties of dataframes

car::some() displays 10 (by default) randomly selected participants from the data frame

some(d)
some(d,20) #passing second argument allows display of more (or less) cases

utils::head() displays the first n rows of the dataframe

head(d,20) #passing second argument allows display of more (or less) cases

utils::tail() displays the last n rows of the dataframe

tail(d)
tail(d,20) #passing second argument allows display of more (or less) cases

utils::View() displays dataframe in a crude spreadsheet. [see also relimp::showData()]

View(d)

base::rownames() sets the row names for a dataframe

rownames(d) = as.character(d\$SubID) #set row names to the SubIDs
row.names(d) #print row names for d

base::dim() provides the dimensions (# of rows and columns) of the dataframe

dim(d)

base::nrow() provides the # of rows (observations) of the dataframe

nrow(d)

base::ncol() provides the # of columns (variables) of the dataframe

ncol(d)

base::str() compactly provides the stucture of an object

str(d)

base::names() gets or sets the names of an object.

names(d) #displays the variable names of the dataframe
names(d) = c(‘VarName1’, ‘VarName2’, ‘VarName3’) #set names of three variables in dData
names(d) = ‘VarName3’ #set name of third variable to ‘VarName3’

### Indexing

base::which() returns indices for specific cases based on variables in dataframe

which(d\$Age> 21) #return indices for cases based on Age
which(d\$BevGroup == ‘alcohol’) #return indices for cases where factor BevGroup = alcohol (level label)

stats::na.omit() selects subset of non-missing cases in dataframe

dNew = na.omit(d)

stats::complete.cases() returns a logical vector indicating which cases are complete, i.e., have no missing values.

complete.cases(d\$X1, d\$X2)
d= d[complete.cases(d\$X1,d\$X1),]

car::whichNames() returns indices of specific row names in dataframe

whichNames(c(‘1001’, ‘2022’), d) #returns indices of SubIDs 1002 and 2033 (assuming SubIDs are row names)

Get row name of specific indices

rownames(d) #returns row name of case 10
rownames(d)[1:10] #returns row names of first 10 cases

Selecting a single variable in a dataframe.

d\$MyVariable
d #select variable in first column of dataframe

Selecting cases in a dataframe.

d[10, ] #select case 10 in d
d[7:10, ] #select cases 7-10 in d
d[c(7,10,11), ] #select cases 7, 10, 11 in d

## Dataframe Manipulation

### Aggregating data

Use the plyr package. In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. To make an aggregate data file that includes the mean and max number of runs across years for each player, use the following code:

NewData = ddply(.data= baseball, .variables = c(‘id’), .fun= summarise, MeanRuns = mean(r), MaxRuns = max(r))

### Convert dataframe from LONG to WIDE format

Use dcast() from reshape2 package

The dcast formula has the following format: x_variable + x_2 ~ y_variable + y_2 ~ z_variable ~ … The order of the variables makes a difference. The first varies slowest, and the last fastest.

If the combination of variables you supply does not uniquely identify one row in the original data set, you will need to supply an aggregating function, fun.aggregate=. You would typically use fun.aggregate=mean.

First lets create a sample dataframe in LONG format for this example.

SubID sex condition measurement
1 M control 7.9
1 M cond1 12.3
1 M cond2 10.7
2 F control 6.3
2 F cond1 10.6
2 F cond2 11.1
3 F control 9.5
3 F cond1 13.1
3 F cond2 13.8
4 M control 11.5
4 M cond1 13.4
4 M cond2 12.9
‘)

Then use dcast as follows:

dWide = dcast(data= dLong, formula= SubID + sex ~ condition, value.var=”measurement”)

### Convert dataframe from WIDE to LONG format

Use dcast() from reshape2 package You need to specify:

id.vars: the variables that will not be split apart on melt
measure.vars: the variates of the within subject variable
variable name: the name of the within subject variable
value.name: the name of the dependent variable

First, lets make a WIDE example dataframe

SubID sex control cond1 cond2
1 M 7.9 12.3 10.7
2 F 6.3 10.6 11.1
3 F 9.5 13.1 13.8
4 M 11.5 13.4 12.9
‘)

Then use melt():

dLong <- melt(dWide, id.vars=c(‘SubID’,’sex’), measure.vars=c(‘control’, ‘cond1’, ‘cond2′), variable.name=’condition’, value.name=’DV’)

## Summary/Descriptive Statistics

### Calculate summary statistics separately on every subject in dataframe

Use the plyr package. In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. There is a year variable which indicates the calendar year (e.g. 1991) for each year played for each player. To calculate the last year each player played ball choose one of these options:

Option 1 uses summarize to return one row per subject in new dataframe, LastYears:

LastYears = ddply(.data= baseball, .variables= c(‘id’), .fun= summarise, MaxYear = max(year))

Option 2 uses transform to return max year in every existing row in the original dataframe (same value for every row for the same player)

baseball = ddply(.data= baseball, .variables= c(‘id’), .fun= transform, MaxYear = max(year))

Option 3 uses our own anonymous function to demo situation where you need a new or more complex function that doesnt exist (of course, this one does exist):

NewMax = function(x) {max(x, na.rm=TRUE)}
LastYears = ddply(.data= baseball, .variables= c(‘id’), .fun= summarise, MaxYear = NewMax(year))

## Programming and Debugging (DRAFT)

### Conditional branching

If() not vectorized If(x< 0) –x else x

Ifelse() is vectorized

list all logical operators

```! x
x & y
x && y
x | y
x || y
xor(x, y)
```

== != >= <=

return()

### Control structures

#### switch()

convert2meters <- function(x,

```   units=c("inches", "feet", "yards", "miles")) {
units <- match.arg(units)
switch(units,
inches = x * 0.0254,
feet = x * 0.3048,
yards = x * 0.9144,
miles = x * 1609.344)
```

}

#### for()

f=0
for (i in seq(1:10)) {f = f * i}

#### while()

fact3 <- function(x){

```   if ((!is.numeric(x)) || (x != floor(x))
|| (x < 0) || (length(x) > 1))
stop("x must be a non-negative integer")
i <- f <- 1  # initialize
while (i <= x) {
f <- f * i  # accumulate product
i <- i + 1  # increment counter
}
f  # return result
```

}

#### repeat

fact4 <- function(x) {

```   if ((!is.numeric(x)) || (x != floor(x))
|| (x < 0) || (length(x) > 1))
stop("x must be a non-negative integer")
i <- f <- 1  # initialize
repeat {
f <- f * i  # accumulate product
i <- i + 1  # increment counter
if (i > x) break  # termination test
}
f  # return result
```

}

#### recursion

fact5 <- function(x){

```   if (x <= 1) 1  # termination condition
else x * fact5(x - 1)  # recursive call
```

}

### Debugging

browser()
debug() & undebug()

system.time()

debugger() with options(error=dump.frames) & options(error=NULL)

Rprof w/tempfile() & unlink() & summaryRprof()
traceback()
str()
class()

## Iterative Procedures

### Calculate summary statistics separately on every subject in dataframe

Use the plyr package. In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. There is a year variable which indicates the calendar year (e.g. 1991) for each year played for each player. To calculate the last year each player played ball choose one of these options:

Option 1 uses summarize to return one row per subject in new dataframe, LastYears:

LastYears = ddply(.data= baseball, .variables= c(‘id’), .fun= summarise, MaxYear = max(year))

Option 2 uses transform to return max year in every existing row in the original dataframe (same value for every row for the same player)

baseball = ddply(.data= baseball, .variables= c(‘id’), .fun= transform, MaxYear = max(year))

Option 3 uses our own anonymous function to demo situation where you need a new or more complex function that doesnt exist (of course, this one does exist):

NewMax = function(x) {max(x, na.rm=TRUE)}
LastYears = ddply(.data= baseball, .variables= c(‘id’), .fun= summarise, MaxYear = NewMax(year))

### Create and save (to pdf) individual subject plots

In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. To make subject by subject plots of runs (r) by at bats (ab), do the following:

xlim = range(baseball\$ab)
ylim = range(baseball\$r)
MakePlot =function(df)
{
plot(df\$ab, df\$r, data = df, xlab = ‘at bat’, ylab = ‘runs’)
title(df\$id)
}
pdf(“c:\\paths.pdf”, width = 8, height = 4) #print to pdf
d_ply(.data= baseball, .variables = c(‘id’), .fun = failwith(NA, MakePlot), .print = TRUE)
dev.off() #turn off output to pdf

### Estimate linear models on individual subjects

In this example, we use the baseball dataset, In this dataset, each baseball player has n rows for each of the n years they played ball. To estimate a linear model for each player regressing runs (r) on at bats (ab) and save models in a list, do the following”

DoLM = function(df) {lm(r ~ ab, data=df)}
Models = dlply(.data= baseball, .variables= c(‘id’), .fun= DoLM)

NOTES: Defined DoLM outside of plyr call to demonstrate this functionality. Could include multiple lines of code in DoLM if needed.

### Extract parameters from list of linear models with plyr

In this example, we use the baseball dataset, We first make a list of simple linear models within subject as in the previous example

DoLM = function(df) {lm(r ~ ab, data=df)}
Models = dlply(.data= baseball, .variables= c(‘id’), .fun= DoLM)

To extract the parameters (and model r-squared) and save as variables in a data frame, do the following:

rsq = function(x) summary(x)\$r.squared
Parameters <- ldply(Models, function(x) c(coef(x), rsquare = rsq(x)))

## John Curtin’s R Reference Card

### R Installation and Workspace

utils::install.packages() installs the package or packages listed. Must load package (using library()) after installation.

install.packages(‘car’, dependencies = TRUE)

base::library() loads a package into the workspace for use or lists available packages

library(car)
library() #lists all installed packages

base::detach(‘package:car’) removes the package from the workspace.

detach(‘package:car’)

base::search() returns list of attached packages and dataframes.

search()

base::ls() returns names of objects in workspace.

ls()

base::rm() removes an object from the workspace.

rm(dData) #removes dataframe dData
rm(dData, mLM) #removes dData and mLM
rm(list = ls()) #removes all objects in workspace (with no warnings).

base::options() get or set options for R

options(digits=4) #sets digits options to 4
options() #returns all options
options(‘digits’) #returns option setting for digits
names(options()) #returns the names of all options

base::source() accept input from the named file. Used typically to load function libraries that are not in packages.

source(‘P:\\Methods\\Statistics\\R\\functions\\CurtinGLM.R’)

utils::str() returns the structure of an object.

str(dData) #return structure of the dataframe dData

base::class() returns the class of an object. Useful for debugging.

class(dData)
class(mLM)

utils::methods() List all available methods for an S3 generic function, or all methods for a class.

methods(lm)

utils::data() loads specified data sets, or list the available data sets.

data() #lists available data sets
data(USArrests) #loads USArrests data.frame

grDevices::graphics.off() closes all graphic devices.

grDevices::dev.off() closes current graphic device.

ctrl-L clears the console.

rm(list = ls()) clears the workspace

### Help

The CRAN Task Views webpage provide overviews on various topics in R.

utils::help provides help on functions.  ? is shortcut.

help(lm)
help(lm)
?lm
help(‘for’)
help(package= Hmisc) #help on a package

utils::apropos() finds funcions or other objects by partial name.

apropos(‘lm’)
apropos(‘log’)

utils::help.search() provides a broader search of a topic in all installed packages.  ?? is a shortcut.

help.search(‘log’)
??’linear model’

base::args() displays the argument names and corresponding default values of a function.

args(lm)

utils::RSiteSearch() provides a search of websites, mailing lists, etc.

RSiteSearch(‘loglinear’,’functions’)

### General Useful Functions

base::sign returns a vector with the signs of the corresponding elements in its single argument (the sign of a real number is 1, 0, or -1 if the number is positive, zero, or negative, respectively).

sign(c(-2, -1, 0, 1, 2))

base::abs returns a vector with the absolute values of elements in its single argument.

abs(c(-2, 0, 2))

base::identical(x,y) compare R objects ‘x’ and ‘y’ and tests for equality. Helpful when comparing vectors where == would return a vector but identical returns single TRUE or FALSE.

identical(1, 1)
identical(c(1,2), c(1,3))

base::is.element(x,y) tests ‘x %in% y’ and returns logical vector that is length of x.

is.element(c(1,2), c(1,3,5,7))

base::is.na() indicates which elements are missing.

is.na(c(1,NA,3))

base::unique()

base::sort(x, decreasing = FALSE, index.return = FALSE, …) sorts/orders a vector or factor (partially) into ascending (or descending) order. For ordering along more than one variable, (e.g., for sorting data frames), see order(). index.return=TRUE will return indices for the new sorted vector

sort(c(2,1,5))
sort(c(2,1,5), index.return=TRUE)

MASS::fractions() finds rational approximations to the components of a real numeric object.

fractions(c(.5, .33333333))

### Dataframes

#### Indexing and manipulating

utils::fix() allows simple editing of an exisiting dataframe via a crude text editor.

fix(dData)

Creating a new dataframe with a subset of variables.

dNew = dData[,c(‘SubID’, ‘BevGroup’, ‘Sex’, ‘FPS1’)

Creating a new dataframe w/o specific row #s.

dNew = dData[-c(1:5,10),] #remove rows 1-5, 10

Creating a new dataframe based on values of a variable.

dNew = dData[dData\$Age > 21,] #Select participants with Age < 21
dNew = dData[dData\$Age > mean(dData\$Age),] #Select participants with Age > mean Age

Remove a variable from dataframe.

dData\$SubID <- NULL

Create a data frame from all combinations of the supplied vectors or factors
expand.grid(c(‘control’, ‘placebo’, ‘alcohol’), c(‘word first’, ‘color first’))

```    Var1        Var2
```

1 control word first
2 placebo word first
3 alcohol word first
4 control color first
5 placebo color first
6 alcohol color first

Reshaping dataframe from Wide to Long format.

dLong <- melt(dWide, id.vars = c(“SubID”, “Sex”, “Alcohol”, “Baseline”), variable.name = “Condition”, value.name = “Startle”)

1st argument = Wide format data frame
2nd argument = id.vars = List variables you want to keep in rows in the new data frame
3rd = variable.name = Name of new column header/variable
4th argument = value.name = Value to be input in columns

Reshaping dataframe from Long to Wide format.

dWide <- dcast(dLong, SubID + Sex + Alcohol + Baseline ~ Condition, value.var = “Startle”)

1st argument = Long format data frame
2nd argument = Variables on the left of the ~ represents data that are staying in columns.
2nd argument = Variables on the right of the ~ represent variables to be transformed into wide format.
3rd argument = value.var = Represents the numeric values that are being transformed into wide format.

NOTE: Need to add information on merging dataframes

### Working with Variables (DRAFT)

#### General manipulations

base::cbind() combines vectors together as columns

test = cbind(dData\$X1, dData\$X2, dData\$X3) #sets test to three columns from dData

### String Pattern Matching

search for a string pattern
• foo<-c(‘a’,’b’,’c’) #create variable with list of strings
• grep(“a”,foo, value=FALSE) #returns a list of indices of all levels of foo equal to ‘a’
• grep(“a”,foo, value=TRUE) #returns a list of strings in foo equal to ‘a’
• grepl(“a”,foo) #returns a logical index of levels of foo equal to ‘a’ (eg, returns 0 and 1 for every level of foo)
search for a string pattern with wildcards
• foo<-c(‘abc’,’def’,’ghi’) #create variable with list of strings
• grep(glob2rx(‘*e*’),foo) #returns a list of all levels in foo containing the string ‘e’

#### Quantitative Variable manipulations

base::scale() mean and/or sd transforms a matrix. Default returns a matrix so must use index if working with variable in data.frame.

dData\$cX1 = scale(dData\$X1, center=TRUE) #mean center X1
dData\$zX1 = scale(dData\$X1, center=TRUE, scale=TRUE) #standardize X1

car::recode() recodes a numeric vector, character vector, or factor according to simple recode specifications.

dData\$NewX1 = recode(dData\$X1, ‘lo:50″=1; 51:hi=2’)
dData\$NewX2 = recode(dData\$X2, ‘c(1,2)=”A”; else=”B”‘)

base::rowMeans() is used to create a mean across a row (i.e., across variables in a data.frame). See also colMeans(), rowSums(), & colSums().
dData\$MeanX123 = rowMeans(dData\$X1,dData\$X2, dData\$X3)

### Summary Statistics (DRAFT)

base::print() is used to print the object to the screen. It is a generic function whose method depends on the object

print(c(1.234, 2.3456, 3),digits=2)

base::summary() is used to summarize an arguement. It is a generic function whose method depends on the object.

summary(dData) #provide summary statistics for variables in a dataframe
summary(mLM) #provide summary statistics for a linear model object

psych::describe() provides many common summary statistics for variables in a dataframe.

describe(dData)

descriptives by group

describe.by(dData, group,…)

base::table() provides cross tabs of counts for factors

table(Sex)
table (BevGroup, Sex)

xtabs

base::apply() returns a vector or array or list of values obtained by applying a function to margins of an array or data.frame. See also lapply(), sapply(), & tapply()

apply(dData, 1, mean) #sum across each row in dData
apply(dData, 2, sum) #sum down each column in dData
apply(dData, 1, function(x) 7*mean(x, na.rm=TRUE)) #using anon function across rows in dData
apply(dData, 1, make.scale) #applying user-defined function named make.scale()

### Bivariate Statistics (DRAFT)

#### Correlation

stats::cor()

cor(D1)
cor(D1[,c(“mp1_con”, “mp1_nem”)])

stats::cor.test()

psych::corr.test()

psych::fisherz()

psych::fisherz2r()

psych::r.test()

psychometric::CIr()

CIr(.5, n=100)
CIr(.3, n=100, level= 0.99)

corpcor::cor2pcor()

stats::t.test()

### Linear Models (DRAFT)

car::box.cox()
MASS::boxcox
car::box.tidwell()
car::ncvTest()
car::qq-plot()
car::cr.plots()
model.matrix (~ type, data=dData)

### Graphing (DRAFT)

There are many sample figures and additional resources for Graphing in R in our Wiki. In addition, the CRAN Graphics Task View provides a nice overview of graphing in R.

#### Options

graphics::par() sets and returns display (and many other) options for R. Type help(par) for detailed information on all parameters.

par() #returns names and values of all current options
par(cex.lab=1.5, cex.axis=1.2, lwd=2)

mfrow is used to produce multipanel figures filled by row (see also mfcol).

par(mfrow = c(2,2)) #set options to produce a four panel figure filled topleft, top right, bottom left, bottom right.
par(mfrow = c(1,2) #set options to produce two panel horizonal orientation
par(mfrow = c(2,1) #set options to produce two panel vertical orientation

palette()

rainbox()

gray()

colors()

#### High-level plotting functions

graphics:::plot()

plot(aex_tot ~ sss_tot, xlab=”MPQ Negative Emotionality”, ylab=”Anger Expression”)

hist()

hist(Data\$aex_tot, main=”Anger Expression”)

#### Low-level plotting functions

graphics:::abline()

abline(lm(aex_tot ~ sss_tot),col= “red”, lwd=4)
abline(h=mean(D1\$aex_tot), col=”blue”, lwd=4)

graphics:::lines()

graphics:::points()

graphics:::axis()

graphics:::legend()

text()

polygon()

curve()

arrows()

#### Other useful graphing functions

identify()

identify(mp1_con,sss_tot)
identify(D1\$mp1,con,D1\$sss_tot,labels=row.names(Data)

density()

plot(density(Data\$aex_tot),main=”Anger Expression”)

jitter()
Create multi-panel plot

locator()

.

### Mapping

https://rstudio.github.io/leaflet/

### Building Packages

Read this for putting packages on CRAN http://cran.r-project.org/doc/manuals/R-exts.html#Submitting-a-package-to-CRAN

Using devtools to check and build package

• Choose version number for release. See: 
• Make sure package is up to date on Sourceforge
• export package to C:\RBuild\lmSupport\
• library(devtools)
• set working directory in RStudio to package folder (e.g., C:\RBuild\lmSupport\)
• check(document=FALSE)
• build()
• Upload to CRAN here: http://cran.r-project.org/submit.html

Other Notes

• To install the tar in R use, install.packages(‘P:/Methods/R/lmSupport/lmSupport_2.9.8.tar.gz’, repos=NULL, type= ‘source’)

## Other R Reference Cards

R Reference Card by Tom Short

Regression Reference Card by Vito Ricci

Short R Reference Card by Jonathan Baron