=========================== Interface to the R language

R has a wealth of libraries that it would be foolish to ignore (or try to reimplement all of them).

This packages is here to offer one to play with Julia while calling R whenever it has a library that would be needed.

Installation

Requirements

• R, compiled with the option --enable-R-shlib
• R executable in the ${PATH} (or path specified in the file Make.inc)

Build and install

This is a valid Julia package. Once you have all the METADATA.jl jazz for Julia packages sorted out (exercise left to the reader), installing a building will be done with:

julia> Pkg.add("Rif")

Once this is done, in a subsequent Julia process one can just write

julia> using Rif

The first time it is done, the C part of the package will be compiled against the R found in the $PATH.

Usage

Initialization

The package is using an embedded R, which needs to be initalized before anything useful can be done.

using Rif

Rif.initr()

If needed, the initialization parameters can be specified:

# set initialization parameters for the embedded R
argv = ["Julia-R", "--slave"]
# set the parameters
Rif.setinitargs(argv)
# initialize embedded R
Rif.initr()

Vectors and arrays

Vectors

In R there are no scalars, only vectors.

# Use R's c()
v = Rif.cR(1,2,3)

# new anonymous R vector of integers
v = Int32[1,2,3]
v_r = Rif.RArray{Int32,1}(v)
elt = v_r[1]

# new anonymous R vector of doubles
v = Float64[1.0,2.0,3.0]
v_r = Rif.RArray{Float64,1}(v)
elt = v_r[1]

# new anonymous R vector of strings
v = ["abc","def","ghi"]
v_r = Rif.RArray{ASCIIString,1}(v)
elt = v_r[1]

Matrices and Arrays

Matrices are arrays of dimension 2:

v = Int32[1 2 3; 4 5 6]
v_r = Rif.RArray{Int32,2}(v)
elt = v_r[1,1]
v_r[1,1] = int32(10)

Environments

In R variables are defined in environments and calls are evaluated in environments as well. One can think of them as namespaces. When running R interactively, one is normally in the "Global Environment" (things are only different when in the debugger).

# R's global environment
ge = Rif.getGlobalEnv()
# bind the anonymous R object in v_r to the name "foo" in the
# global environment
ge["foo"] = v_r

# get an R object, starting the search from a given environment
# (here from GlobalEnv, so like it would be from the R console)
letters = Rif.get(ge, "letters")

Functions

# get the R function 'date()'
r_date = Rif.get(ge, "date")
# call it without parameters
res_date = Rif.rcall(r_date, [], [], ge)
res_date[1]

# get the function 'mean()'
r_mean = Rif.get(ge, "mean")
v = Int32[1,2,3]
v_r = Rif.RArray{Int32, 1}(v)
# call it with a named parameter
res_mean = Rif.rcall(r_mean, [v_r,], ["x",], ge)

# other way to achieve the same:
res_mean = Rif.rcall(r_mean, [], ["x" => v_r])
res_mean[1]

R code in strings

using Rif

# load the R package "cluster"
R("require(cluster)")

# today's date by calling R's date()
Rif.rcall(R("date"))[1]

GUI eventloop

When working with gui windows interactively, it makes sure the gui is not being blocked. Especially important for graphic devices.

Rif.GUI()

Examples

Hierarchical clustering

We are using random data so the example is somewhat futile

require("Rif")
using Rif
initr()

r_base = Rif.importr("base")
r_stats = Rif.importr("stats")
r_graphics = Rif.importr("graphics")

m = r_base.matrix(r_stats.rnorm(100); nrow=20)

# A Julia matrix mj of type (Array{Float64, 2}) could
# be used with
# m = RArray{Float64,2}(mj)

d = r_stats.dist(m)
hc = r_stats.hclust(d)
r_graphics.plot(hc; 
                sub=cR(""),
                xlab=cR(""))

ggbio (in Bioconductor)

Not-so-simple example, using some of the documentation for autoplot() in the Bioconductor package ggbio.

using Rif
initr()

R("set.seed(1)")
N = 1000
r_gr = Rif.importr("GenomicRanges")
r_ir = Rif.importr("IRanges")
r_base = Rif.importr("base")
r_stats = Rif.importr("stats")
function sampleR(robj, size, replace)
    r_base.sample(robj;
		  size=size, 
                  replace=replace)
end

gr = r_gr.GRanges(;
	          seqnames=sampleR(cR("chr1", "chr2", "chr3"), N, true),
                  ranges=r_ir.IRanges(;
				      start=sampleR(R("1:300"), N, true),
                                      width=sampleR(R("70:75"), N, true)),
                  strand=sampleR(cR("+", "-", "*"), N, true),
                  value=r_stats.rnorm(cR(N), cR(10), cR(3)),
                  score=r_stats.rnorm(cR(N), cR(100), cR(30)),
                  sample=sampleR(cR("Normal", "Tumor"), N, true), 
                  pair=sampleR(R("letters"), N, true))

For reference, the original R code:

set.seed(1)
N <- 1000
library(GenomicRanges)
gr <- GRanges(seqnames = 
              sample(c("chr1", "chr2", "chr3"),
                       size = N, replace = TRUE),
              IRanges(
                      start = sample(1:300, size = N, replace = TRUE),
                      width = sample(70:75, size = N,replace = TRUE)),
              strand = sample(c("+", "-", "*"), size = N, 
                              replace = TRUE),
              value = rnorm(N, 10, 3), score = rnorm(N, 100, 30),
              sample = sample(c("Normal", "Tumor"), 
              size = N, replace = TRUE),
              pair = sample(letters, size = N, 
              replace = TRUE))

ggbio = importr("ggbio")
gr = r_gr.(symbol("seqlengths<-"))(gr, RArray{Int32, 1}(Int32[400, 500, 700]))

# still working out how match the R string code below with Julia/Rif
#r_base.(symbol("["))(gr,
#                     r_base.sample(R("1:" * string(r_base.length(gr)[1]))),
#                     r_base.length(gr))
##values(gr)$to.gr <- gr[sample(1:length(gr), size = length(gr))]
##idx <- sample(1:length(gr), size = 50)
##gr <- gr[idx]

# in the meantime the plot _is_ working
+(x::RArray{Sexp,1}, y::RArray{Sexp,1})=r_base.(symbol("+"))(x,y)

ggplot2 = importr("ggplot2")
p = ggplot2.ggplot() + 
  ggbio.layout_circle(gr; geom = "ideo", fill = "gray70", 
                radius = 7, trackWidth = 3) +
  ggbio.layout_circle(gr; geom = "bar", radius = 10, trackWidth = 4, 
                aes=ggplot2.aes_string(;fill = "score", y = "score")) +
  ggbio.layout_circle(gr; geom = "point", color = "red", radius = 14,
                trackWidth = 3, grid = true,
                aes=ggplot2.aes_string(;y = "score")) #+
  ggbio.layout_circle(gr; geom = "link", (symbol("linked.to")) = "to.gr", 
                radius = 6, trackWidth = 1)

r_base.print(p)

R code:

require(ggbio)
seqlengths(gr) <- c(400, 500, 700)
values(gr)$to.gr <- gr[sample(1:length(gr), size = length(gr))]
idx <- sample(1:length(gr), size = 50)
gr <- gr[idx]
ggplot() + 
  layout_circle(gr, geom = "ideo", fill = "gray70", 
                radius = 7, trackWidth = 3) +
  layout_circle(gr, geom = "bar", radius = 10, trackWidth = 4, 
                aes(fill = score, y = score)) +
  layout_circle(gr, geom = "point", color = "red", radius = 14,
                trackWidth = 3, grid = TRUE, aes(y = score)) +
  layout_circle(gr, geom = "link", linked.to = "to.gr", 
                radius = 6, trackWidth = 1)