R character string

R function closure

R complex vector

R environment

R integer vector

R function call

R logical vector

R pairs (cons) list cell

R NULL value

AnRObject is a Julia wrapper for an R object (known as an "S-expression" or "SEXP"). It is stored as a pointer which is protected from the R garbage collector, until theRObject itself is finalized by Julia. The parameter is the type of the S-expression.

When called with a Julia object as an argument, a corresponding R object is constructed.

julia> RObject(1)RObject{IntSxp}[1] 1julia> RObject(1:3)RObject{IntSxp}[1] 1 2 3julia> RObject(1.0:3.0)RObject{RealSxp}[1] 1 2 3

R real vector

R S4 object

R vector of character strings

RCall.jl's typeSxp mirrors the R symbolic expression recordSEXPREC in R API. These are represented by a pointerPtr{S<:Sxp} (which is calledSEXP in R API).

R list (i.e. Array{Any,1})

R "any" object

R byte code

R built-in function

R dot-dot-dot object

R expression vector

R external pointer

R promise

R Class

R byte vector

R special function

R Sxp header: a pointer to this is used for unknown types.

R symbol

R weak reference

Check if there are any NA values in the vector.

Return a particular attribute of an RObject

Returns the class of an R object.

Returns the names of an R vector.

Check if the ith member of s coorespond to R's NA values.

Check if the members of a vector are NA values. Always return a BitArray.

Check if values correspond to R's NULL object.

Evaluate a function in the global environment. The first argument corresponds to the function to be called. It can be either a FunctionSxp type, a SymSxp or a Symbol.

rcopy(r) copies the contents of an R object into a corresponding canonical Julia type.

Evaluate an R symbol or language object (i.e. a function call) in an R try/catch block, returning an RObject.

Import an R package as a julia module.

gg = rimport("ggplot2")

Create a function call from a function pointer and a list of arguments and return it as an RObject, which can then be evaulated

robject(x) converts a Julia objectx to a corresponding RObject implictly. Explict conversions could be called withrobject(<R Class>, x).

Parse a string as an R expression, returning an RObject.

Print the value of an Sxp using R's printing mechanism

Set a particular attribute of an RObject

Set the class of an R object.

Set the names of an R vector.

sexp(x) converts a Julia objectx to a pointer to a corresponding Sxp Object.

Convert aPtr{UnknownSxp} to an approptiatePtr{S<:Sxp}.

Wrap a Julia object an a RPtr{ExtPtrSxp}.

We store the pointer and the object in a const Dict to prevent it being removed by the Julia GC.

Wrap a callable Julia objectf an a RClosSxpPtr.

Constructs the following R code

function(...) .External(juliaCallback, fExPtr, ...)

Element types of R vectors.

extract the value of symbol s in the environment e

extract an element from a S4Sxp by label

extract an element from a PairListSxp by label

Set element of a VectorSxp by a label.

extract the i-th element of a PairListSxp

Determines the encoding of the CharSxp. This is determined by the 'gp' part of the sxpinfo (this is the middle 16 bits).

• 0x00000200 (bit 1): set of bytes (no known encoding)
• 0x00000400 (bit 2): Latin-1
• 0x00000800 (bit 3): UTF-8
• 0x00004000 (bit 6): ASCII

We only support ASCII and UTF-8.

Sxp methods forlength return the R length.

Rf_xlength handles Sxps that are not vector-like and R's "long vectors", which have a negative value for thelength member.

Returns the names of an R vector, the result is converted to a Julia symbol array.

assign value v to symbol s in the environment e

extract an element from a S4Sxp by label

Set element of a PairListSxp by a label.

Set element of a VectorSxp by a label.

assign value v to the i-th element of a PairListSxp

Returns the size of an R object.

The R NAMED property, represented by 2 bits in the info field. This can take values 0,1 or 2, corresponding to whether it is bound to 0,1 or 2 or more symbols. See http://cran.r-project.org/doc/manuals/r-patched/R-exts.html#Named-objects-and-copying

Called by the R finalizer.

endEmbeddedR()

Close embedded R session.

Event Callback: allows R to process Julia events when R is busy. For example, writing output to stdout while running an expensive R command.

find namespace by name of the namespace, it is not error tolerant.

get namespace by name of the namespace. It is safer to be used than findNamespace as it checks bound.

Get the R parser error msg for the previous parsing result.

Called after cell evaluation. Closes graphics device and displays files in notebook.

Set options for R plotting with IJulia.

The first argument should be a MIME object: currently supported are

• MIME("image/png") [default]
• MIME("image/svg+xml")

The remaining arguments (keyword only) are passed to the appropriate R graphics device: see the relevant R help for details.

initEmbeddedR()

This initializes an embedded R session. It should only be called when R is not already running (e.g. if Julia is running inside an R session)

Check if a value corresponds to R's sentinel NA values. These function should not be exported.

The function called by R .External for Julia callbacks.

It receives aPtr{ListSxp} containing

• a pointer to the function itself (Ptr{ExtPtrSxp})
• a pointer to the Julia function (Ptr{ExtPtrSxp})
• any arguments (asPtr{S<:Sxp})

Create an Ptr{ExtPtrSxp} object

Register a function pointer as an R NativeSymbol. We technically are supposed to use RregisterRoutines. Starting from R 3.4, `RMakeExternalPtrFn` is a part of R API in R 3.4. It is probably safe to such to make the external pointer.

NA element for each R base class

newEnvironment([env])

Create a new environment which extends environmentenv (globalEnv by default).

A pure julia wrapper of R_ParseVector

Prepare code for evaluating the julia expressions. When the code is execulated, the results are stored in the R environment#JL.

Prevent garbage collection of an R object. Object can be released viarelease.

This is slower thanprotect, as it requires searching an internal list, but more flexible.

Stack-based protection of garbage collection of R objects. Objects are released viaunprotect. Returns the same pointer, allowing inline use.

This is faster thanpreserve, but more restrictive. Really only useful inside functions.

Evaluate a function in the global environment. The first argument corresponds to the function to be called. It can be either a FunctionSxp type, a SymSxp or a Symbol.

Register finalizer to be called by the R GC.

Release object that has been gc protected bypreserve.

Render an inline R script, substituting invalid "$(Expr(:incomplete, "incomplete: invalid string syntax"))

Evaluate an R expression array iteratively. Ifthrow_error isfalse, the error message and warning will be thrown to stderr.

Evaluate an R symbol or language object (i.e. a function call) in an R try/catch block, returning a Sxp pointer.

Create a function call from a list of arguments

Parse a string as an R expression, returning a Sxp pointer.

RParseVector wrapped by RtryCatchError. It catches possible R'sstop calls which may cause longjmp in c.

Set the variable .Last.value to a given value

Create an argument list for an R function call, with a varargs "dots" at the end.

The SEXPTYPE number of aSxp

Determined from the trailing 5 bits of the first 32-bit word. Is a 0-based index into theinfo field of aSxpHead.

A pure julia wrapper of R_tryEval.

Release lastn objects gc-protected byprotect.

The same asunsafe_vec, except returns an appropriately sized array.

Represent the contents of a VectorSxp type as aVector.

This doesnot copy the contents. If the argument is not named (in R) or otherwise protected from R's garbage collection (e.g. by keeping the containing RObject in scope) the contents of this vector can be modified or could cause a memory error when accessed.

The contents are as stored in R. Missing values (NA's) are represented in R by sentinels. Missing data values in RealSxp and CplxSxp show up asNaN andNaN + NaNim, respectively. Missing data in IntSxp show up as-2147483648, the minimum 32-bit integer value. Internally aLglSxp is represented asVector{Int32}. The convention is that0 isfalse,-2147483648 isNA and all other values representtrue.

validate_libR(libR, raise=true)

Checks that the R librarylibR can be loaded and is satisfies version requirements.

Ifraise is set tofalse, then returns a boolean indicating success rather than throwing exceptions.

R API callback to write console output.

R"..."

An inline R expression, the result of which is evaluated and returned as anRObject.

It supports substitution of Julia variables and expressions via prefix with$ whenever not valid R syntax (i.e. when not immediately following another completed R expression):

R"glm(Sepal.Length ~ Sepal.Width, data=$iris)"

It is also possible to pass Julia expressions:

R"plot(getfield(RCall, Symbol("##49#50"))())"

All such Julia expressions are evaluated once, before the R expression is evaluated.

The expression does not support assigning to Julia variables, so the only way retrieve values from R via the return value.

Copies variables from R to Julia using the same name.

Import an R Package as a Julia module. For example,

@rimport ggplot2

is equivalent toggplot2 = rimport("ggplot2") with error checking.

You can also use classic Python syntax to make an alias:@rimport *package-name* as *shorthand*

@rimport ggplot2 as gg

which is equivalent togg = rimport("ggplot2").

Load all exported functions/objects of an R package to the current module. Almost equivalent to

__temp__ = rimport("ggplot2")using .__temp__

Copies variables from Julia to R using the same name.

Returns a variable named "str". Useful for passing keyword arguments containing dots.

R global Environment.

globalEnv[:x] = 1globalEnv[:x]

Julia types (typically functions) which are wrapped inPtr{ExtPtrSxp} are stored here to prevent garbage collection by Julia.

vector of R Sxp types