Internal API
Types
RCall.AnySxp
— TypeR "any" object
RCall.BcodeSxp
— TypeR byte code
RCall.BuiltinSxp
— TypeR built-in function
RCall.CharSxp
— TypeR character string
RCall.ClosSxp
— TypeR function closure
RCall.CplxSxp
— TypeR complex vector
RCall.DotSxp
— TypeR dot-dot-dot object
RCall.EnvSxp
— TypeR environment
RCall.ExprSxp
— TypeR expression vector
RCall.ExtPtrSxp
— TypeR external pointer
RCall.IntSxp
— TypeR integer vector
RCall.LangSxp
— TypeR function call
RCall.LglSxp
— TypeR logical vector
RCall.ListSxp
— TypeR pairs (cons) list cell
RCall.NilSxp
— TypeR NULL value
RCall.PromSxp
— TypeR promise
RCall.RClass
— TypeR Class
RCall.RObject
— TypeAn RObject
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 the RObject
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] 1
julia> RObject(1:3)
RObject{IntSxp}
[1] 1 2 3
julia> RObject(1.0:3.0)
RObject{RealSxp}
[1] 1 2 3
RCall.RawSxp
— TypeR byte vector
RCall.RealSxp
— TypeR real vector
RCall.S4Sxp
— TypeR S4 object
RCall.SpecialSxp
— TypeR special function
RCall.StrSxp
— TypeR vector of character strings
RCall.Sxp
— TypeRCall.jl's type Sxp
mirrors the R symbolic expression record SEXPREC
in R API. These are represented by a pointer Ptr{S<:Sxp}
(which is called SEXP
in R API).
RCall.SxpHead
— TypeR Sxp header: a pointer to this is used for unknown types.
RCall.SymSxp
— TypeR symbol
RCall.VecSxp
— TypeR list (i.e. Array{Any,1})
RCall.WeakRefSxp
— TypeR weak reference
Methods
Base.eltype
— MethodElement types of R vectors.
Base.getindex
— Methodextract the value of symbol s in the environment e
Base.getindex
— Methodextract an element from a S4Sxp by label
Base.getindex
— Methodextract an element from a PairListSxp by label
Base.getindex
— MethodSet element of a VectorSxp by a label.
Base.getindex
— Methodextract the i-th element of a PairListSxp
Base.isascii
— MethodDetermines 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.
Base.length
— MethodSxp methods for length
return the R length.
Rf_xlength
handles Sxps that are not vector-like and R's "long vectors", which have a negative value for the length
member.
Base.names
— MethodReturns the names of an R vector, the result is converted to a Julia symbol array.
Base.setindex!
— Methodassign value v to symbol s in the environment e
Base.setindex!
— Methodextract an element from a S4Sxp by label
Base.setindex!
— MethodSet element of a PairListSxp by a label.
Base.setindex!
— MethodSet element of a VectorSxp by a label.
Base.setindex!
— Methodassign value v to the i-th element of a PairListSxp
Base.size
— MethodReturns the size of an R object.
RCall.anyna
— MethodCheck if there are any NA values in the vector.
RCall.bound
— MethodThe 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
RCall.decref_extptr
— MethodCalled by the R finalizer.
RCall.endEmbeddedR
— MethodendEmbeddedR()
Close embedded R session.
RCall.findNamespace
— Methodfind namespace by name of the namespace, it is not error tolerant.
RCall.getNamespace
— Methodget namespace by name of the namespace. It is safer to be used than findNamespace as it checks bound.
RCall.getParseErrorMsg
— MethodGet the R parser error msg for the previous parsing result.
RCall.getattrib
— MethodReturn a particular attribute of an RObject
RCall.getclass
— MethodReturns the class of an R object.
RCall.getnames
— MethodReturns the names of an R vector.
RCall.ijulia_displayplots
— MethodCalled after cell evaluation. Closes graphics device and displays files in notebook.
RCall.ijulia_setdevice
— MethodSet 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.
RCall.initEmbeddedR
— MethodinitEmbeddedR()
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)
RCall.isNA
— MethodCheck if a value corresponds to R's sentinel NA values. These function should not be exported.
RCall.isna
— MethodCheck if the ith member of s correspond to R's NA values.
RCall.isna
— MethodCheck if the members of a vector are NA values. Always return a BitArray.
RCall.isnull
— MethodCheck if values correspond to R's NULL object.
RCall.julia_extptr_callback
— MethodThe function called by R .External for Julia callbacks.
It receives a Ptr{ListSxp}
containing
- a pointer to the function itself (
Ptr{ExtPtrSxp}
) - a pointer to the Julia function (
Ptr{ExtPtrSxp}
) - any arguments (as
Ptr{S<:Sxp}
)
RCall.makeExternalPtr
— FunctionCreate an Ptr{ExtPtrSxp} object
RCall.makeNativeSymbolRef
— MethodRegister 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.
RCall.naeltype
— MethodNA element for each R base class
RCall.newEnvironment
— MethodnewEnvironment([env])
Create a new environment which extends environment env
(globalEnv
by default).
RCall.parseVector
— MethodA pure julia wrapper of R_ParseVector
RCall.polled_events
— Methodpolled_events()::Cvoid
Event Callback: allows R to process Julia events when R is busy. For example, writing output to stdout while running an expensive R command.
See Writing R Extensions: Calling R.dll directly and Writing R Extensions: Meshing Event Loops
RCall.prepare_inline_julia_code
— FunctionPrepare code for evaluating the julia expressions. When the code is evaluated, the results are stored in the R environment #JL
.
RCall.preserve
— MethodPrevent garbage collection of an R object. Object can be released via release
.
This is slower than protect
, as it requires searching an internal list, but more flexible.
RCall.protect
— MethodStack-based protection of garbage collection of R objects. Objects are released via unprotect
. Returns the same pointer, allowing inline use.
This is faster than preserve
, but more restrictive. Really only useful inside functions.
RCall.rcall
— MethodEvaluate 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.
RCall.rcall_p
— MethodEvaluate 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.
RCall.rcopy
— Methodrcopy(r)
copies the contents of an R object into a corresponding canonical Julia type.
RCall.read_console
— MethodRCall.registerCFinalizerEx
— MethodRegister finalizer to be called by the R GC.
RCall.release
— MethodRelease object that has been gc protected by preserve
.
RCall.render
— MethodRender an inline R script, substituting invalid "$(Expr(:incomplete, Base.Meta.ParseError("ParseError:\n# Error @ none:1:26\n\" signs for Julia symbols\n# └ ── unterminated string literal", Base.JuliaSyntax.ParseError(Base.JuliaSyntax.SourceFile("\" signs for Julia symbols", 0, "none", 1, [1, 26]), Base.JuliaSyntax.Diagnostic[Base.JuliaSyntax.Diagnostic(26, 25, :error, "unterminated string literal")], :string))))
RCall.reval
— FunctionEvaluate an R symbol or language object (i.e. a function call) in an R try/catch block, returning an RObject.
RCall.reval_p
— MethodEvaluate an R expression array iteratively. If throw_error
is false
, the error message and warning will be thrown to stderr.
RCall.reval_p
— MethodEvaluate an R symbol or language object (i.e. a function call) in an R try/catch block, returning a Sxp pointer.
RCall.rimport
— FunctionImport an R package as a julia module. Sanitizes the imported symbols by default, because otherwise certain symbols cannot be used.
E.g.: PerformanceAnalytics::charts.Bar
in R becomes PerformanceAnalytics.charts_Bar
in Julia
gg = rimport("ggplot2")
RCall.rlang
— MethodCreate a function call from a function pointer and a list of arguments and return it as an RObject, which can then be evaluated
RCall.rlang_p
— MethodCreate a function call from a list of arguments
RCall.robject
— Methodrobject(x)
converts a Julia object x
to a corresponding RObject implicitly. Explicit conversions could be called with robject(<R Class>, x)
.
RCall.rparse
— MethodParse a string as an R expression, returning an RObject.
RCall.rparse_p
— MethodParse a string as an R expression, returning a Sxp pointer.
RCall.rprint
— MethodPrint the value of an Sxp using R's printing mechanism
RCall.safe_parseVector
— MethodRParseVector wrapped by RtryCatchError. It catches possible R's stop
calls which may cause longjmp in C.
See Writing R Extensions: Condition handling and cleanup code
RCall.set_last_value
— MethodSet the variable .Last.value to a given value
RCall.setattrib!
— MethodSet a particular attribute of an RObject
RCall.setclass!
— MethodSet the class of an R object.
RCall.setnames!
— MethodSet the names of an R vector.
RCall.sexp
— Methodsexp(x)
converts a Julia object x
to a pointer to a corresponding Sxp Object.
RCall.sexp
— MethodConvert a Ptr{UnknownSxp}
to an appropriate Ptr{S<:Sxp}
.
RCall.sexp
— MethodWrap a Julia object an a R Ptr{ExtPtrSxp}
.
We store the pointer and the object in a const Dict to prevent it being removed by the Julia GC.
RCall.sexp
— MethodWrap a callable Julia object f
an a R ClosSxpPtr
.
Constructs the following R code
function(...) .External(juliaCallback, fExPtr, ...)
RCall.sexp_arglist_dots
— MethodCreate an argument list for an R function call, with a varargs "dots" at the end.
RCall.sexpnum
— MethodThe SEXPTYPE number of a Sxp
Determined from the trailing 5 bits of the first 32-bit word. Is a 0-based index into the info
field of a SxpHead
.
RCall.tryEval
— MethodA pure julia wrapper of R_tryEval.
RCall.unprotect
— MethodRelease last n
objects gc-protected by protect
.
RCall.unsafe_array
— MethodThe same as unsafe_vec
, except returns an appropriately sized array.
RCall.unsafe_vec
— MethodRepresent the contents of a VectorSxp type as a Vector
.
This does not 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 as NaN
and NaN + NaNim
, respectively. Missing data in IntSxp show up as -2147483648
, the minimum 32-bit integer value. Internally a LglSxp
is represented as Vector{Int32}
. The convention is that 0
is false
, -2147483648
is NA
and all other values represent true
.
RCall.validate_libR
— Methodvalidate_libR(libR)
Checks that the R library libR
can be loaded and is satisfies version requirements.
RCall.write_console_ex
— Methodwrite_console_ex(buf::Ptr{UInt8},buflen::Cint,otype::Cint)::Cvoid
R_WriteConsoleEx
API callback to write console output.
otype
specifies the output type (regular output or warning/error).
Macros
RCall.@R_str
— MacroR"..."
An inline R expression, the result of which is evaluated and returned as an RObject
.
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(#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.
RCall.@rget
— MacroCopies variables from R to Julia using the same name.
RCall.@rimport
— MacroImport an R Package as a Julia module. For example,
@rimport ggplot2
is equivalent to ggplot2 = 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 to gg = rimport("ggplot2")
.
RCall.@rlibrary
— MacroLoad all exported functions/objects of an R package to the current module. Almost equivalent to
__temp__ = rimport("ggplot2")
using .__temp__
RCall.@rput
— MacroCopies variables from Julia to R using the same name.
RCall.@var_str
— MacroReturns a variable named "str". Useful for passing keyword arguments containing dots.
Constants
RCall.globalEnv
— ConstantR global Environment.
globalEnv[:x] = 1
globalEnv[:x]
RCall.jtypExtPtrs
— ConstantJulia types (typically functions) which are wrapped in Ptr{ExtPtrSxp}
are stored here to prevent garbage collection by Julia.
RCall.typs
— Constantvector of R Sxp types