The following 287 words could not be found in the dictionary of 615 words (including 615 LocalSpellingWords) and are highlighted below:

abbreviated   about   above   absence   accomplish   aggregate   an   and   Annotation   annoying   Another   apply   assign   average   averaged   be   Bio   Bioc   bioc   bioconductor   Biostrings   Board   Brewer   brewer   Bu   But   but   by   call   called   can   cat   character   Clip   Clipboard   clipboard   close   col   color   Color   Colors   column   Column   columns   condition   conditions   contents   dat   dataframe   Dataframe   db   Dbi   defined   denote   Deprecated   didn   different   Divide   don   each   Each   edge   else   Empty   env   environment   Ever   Example   example   expression   fact   factor   Factors   Features   few   file   filename   flatten   following   For   for   forgot   found   fout   frame   from   fruit   function   functions   gene   genefilter   Genomic   get   getting   ggplot2   go   goes   gplots   had   having   Heatmaps   hmcol   holding   How   However   id   identical   if   If   Imagine   important   in   individual   Install   install   instance   into   know   leaves   library   like   lines   list   List   Lite   load   Load   loaded   loading   lot   ls   lsf   make   Manager   mat   matrix   mean   measured   measurements   memory   method   more   move   my   mydf   mytable   name   Name   names   Namespace   ncol   need   needs   new   no   now   Now   nrow   numbers   numeric   Object   object   objects   of   often   on   One   only   operate   Or   or   original   other   outside   package   packages   pal   Palette   parse   pkgs   populate   pre   previously   produce   program   programs   prop   put   quantity   quietly   Ramp   Ranges   Rd   read   recombine   refer   regardless   remember   replicate   replicates   represent   represents   require   respectively   return   returning   rid   rm   row   Row   rows   runif   same   sample   save   saved   Saved   scan   scope   sep   so   some   Sometimes   somewhere   source   space   statement   stats   steps   str   string   String   strings   structure   such   Sums   sweep   sys   table   tables   take   takes   tapply   that   The   the   them   then   There   thing   this   tmp   to   To   top   two   types   under   Use   use   utilize   value   values   variable   various   vector   want   was   way   ways   we   what   When   where   which   will   With   with   without   work   workspace   would   Write   write   written   you   your  

Clear message

Write to the clipboard

Ever produce a list that you want to take somewhere else outside of R without having to write it to a file? Use the ClipBoard!

The only annoying thing is that you have to write them as a character vector. 

# get some random numbers
x <- runif(5)
# write them to the clipboard
writeClipboard(as.character(x))

To move tables of data, use the write.table function: 

mytable <- matrix(1:100, ncol=10, nrow=10)
write.table(mytable, "clipboard", sep="\t")
# suppress row and column names
write.table(mytable, "clipboard", sep="\t", row.names=FALSE, col.names=FALSE)

To move a column of numbers into R from other programs you can use the scan() function. For instance 

# bring a column of numbers from the clipboard into a vector
x <- scan()
# hit Paste, then Return
# or use readClipboard
x <- readClipboard()

How to flatten a matrix in R

If you have a matrix or data frame where some of the rows have values that need to be averaged. There are a few ways to go about this.

Imagine you have a table of gene expression values measured under various conditions. Each row of the table represents a gene, some of the rows represent replicate measurements of that gene. The gene name is found in the column "sys_id". Each column represents a different condition. To average the replicates you could do the following:

Example 1: 

library(stats)

mat <- aggregate(dat[, 2:5], list(dat$sys_id), mean)

Example 2: Create a factor with the column of gene names, then use that factor to apply a function to the values in each individual column, then recombine the columns into a dataframe or matrix.

use tapply()

tapply(data, factor, function)

Colors for Heatmaps

library(RColorBrewer)
hmcol <- colorRampPalette(brewer.pal(10, "RdBu"))(256)

Write lines to a file

# open a file connection
fout <- file("filename", "w")
# print stuff to the connection (usually as part of a loop)
cat("some data", sep="\n", file=fout)
# close the connection
close(fout)

Install a package from CRAN

install.packages("packageName")

Install package from bioconductor

if (!requireNamespace("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
BiocManager::install()

# For individual packages:
BiocManager::install(c("GenomicFeatures", "AnnotationDbi"))

# maybe a bunch of packages:
pkgs <- c("edgeR", "ggplot2","GenomicRanges","GenomicFeatures", "gplots", "RColorBrewer", "GO.db", "topGO", "genefilter", "AnnotationDbi")
BiocManager::install(pkgs)

Deprecated: 

source("http://bioconductor.org/biocLite.R")
# the packages I usually install after a new installation
biocLite("edgeR")
# you can hand it a list of packages
biocLite(c("ggplot2","GenomicRanges","GenomicFeatures", "gplots", "RColorBrewer", "topGO", "genefilter"))

List functions and objects in a package

ls("package:BioString")

# lists functions with call sequences:
lsf.str("package:Biostrings")

Divide each column in a matrix by it Column Sums

Use a function called sweep. 

# create a matrix of random numbers
m <- matrix(sample(1:9,9),nrow=3,ncol=3)

# divide each column by column sums
sweep(m,2,colSums(m),"/")

Another way to do this would be use the prop.table function, which takes a "1" or "2" to denote by Row or by Column respectively. 

prop.table(m,2)

Create an Empty Dataframe

Sometimes you want to create a data structure to populate, with pre-defined data types. How do you do that in R, in the absence of any data? 

mydf <- data.frame(fruit=character(), quantity=numeric(), stringsAsFactors=FALSE)

Load and get name of R Object

Sometimes you want to load a previously saved R object into memory, and you may not remember the name of the object: 

foo <- "my important string of data"
save(foo, file="mySavedObject.RData")

If you call: load("mySavedObject.RData"), the object will be put into your workspace, but you may not remember what it was called, or you may have some code that needs to operate on it regardless of what it is called. How can you refer to it (i.e. work on foo), if you don't know what it's called?

When you load the object, it goes into your environment, and if you assign the load statement to a variable, the name of the loaded object will be in the variable: 

> myObjectName <- load("mySavedObject.RData")
> ls()
[1] "foo"          "myObjectName"
> print(myObjectName)
[1] "foo"

With this method, your object AND a variable holding the name of your object are in your environment. If you had written a program that needs the value of the object, but didn't know it's name, you now have a way to get it: 

myName <- get(myObjectName)
# you could then choose to get rid of the original object:
rm(list=myObjectName)

Now your program has a copy of the contents of the "foo" object called "myName". But now you have an environment with two data objects that are identical. One you know the name of (myName), the other you forgot (foo). However we can get rid of the original like in the example above.

The steps above are often abbreviated as such: 

myName <- get(load("mySavedObject.RData"))

But this leaves you with two objects.

Another way to do this is to load the object into a new environment, get the object into the name of a variable that you know, and then get rid of the environment. 

tmp <- new.env()
myObjectName <- load("mySavedObject.RData", tmp)
myName <- get(myObjectName, tmp)
rm(tmp)

Now *myName* has the contents of *foo* but *foo* is no more.

If you have a lot of objects to parse this way, you could make it into a function: 

getObject <- function(filename){
  tmp <- new.env()
  myObjectName <- load(filename, tmp)
  theObject <- get(myObjectName, tmp)
  rm(tmp)
  return(theObject)
}

myName <- getObject("mySavedObject.RData")

Or you could utilize the fact that function scope will accomplish the same thing, i.e. loading the object into a space, and returning it's value so you can assign it to a name you know, and then getting rid of the original. 

getObject <- function(filename){
  theObject <- get(load(filename))
  return(theObject)
}

myName <- getObject("mySavedObject.RData")

R/Misc (last edited 2019-06-14 16:18:29 by ChrisSeidel)