Provides an R interface to 'Julia', which is a high-level, high-performance dynamic programming language for numerical computing, see < https://julialang.org/> for more information. It provides a high-level interface as well as a low-level interface. Using the high level interface, you could call any 'Julia' function just like any R function with automatic type conversion. Using the low level interface, you could deal with C-level SEXP directly while enjoying the convenience of using a high-level programming language like 'Julia'.
[Table of Contents]
Package JuliaCall
is an R interface to Julia
, which is a high-level,
high-performance dynamic programming language for numerical computing,
see https://julialang.org/ for more information. Below is an image for
Mandelbrot set.
JuliaCall brings more than 100 times speedup of the calculation!
See
https://github.com/Non-Contradiction/JuliaCall/tree/master/example/mandelbrot
for more
information.
To use package JuliaCall
, you first have to install
Julia
on your computer, you can download a
generic binary from https://julialang.org/downloads/ and add it to
your path, and then you can install JuliaCall
just like any other R
packages by
install.packages("JuliaCall")
Note that currently Julia v0.6.x
, Julia v0.7.0
and Julia v1.0
are
all supported by JuliaCall
. But note that some Julia
packages may
not work on Julia v1.0
and you may need to use Julia v0.7.0
for
transition purposes.
You can get the development version of JuliaCall
by
devtools::install_github("Non-Contradiction/JuliaCall")
library(JuliaCall)## Do initial setupjulia <- julia_setup()#> Julia version 1.0.3 at location /Applications/Julia-1.0.app/Contents/Resources/julia/bin will be used.#> Loading setup script for JuliaCall...#> Finish loading setup script for JuliaCall.## If you want to use a julia at a specific location, you could do the following:## julia_setup(JULIA_HOME = "the folder that contains julia binary"),## or you can set JULIA_HOME in command line environment or use `options(...)`## Different ways for using Julia to calculate sqrt(2)# julia$command("a = sqrt(2);"); julia$eval("a")julia_command("a = sqrt(2);"); julia_eval("a")#> [1] 1.414214julia_eval("sqrt(2)")#> [1] 1.414214julia_call("sqrt", 2)#> [1] 1.414214julia_eval("sqrt")(2)#> [1] 1.414214julia_assign("x", sqrt(2)); julia_eval("x")#> [1] 1.414214julia_assign("rsqrt", sqrt); julia_call("rsqrt", 2)#> [1] 1.4142142 %>J% sqrt#> [1] 1.414214## You can use `julia$exists` as `exists` in R to test## whether a function or name exists in Julia or notjulia_exists("sqrt")#> [1] TRUEjulia_exists("c")#> [1] FALSE## Functions related to installing and using Julia packagesjulia_install_package_if_needed("Optim")julia_installed_package("Optim")#> [1] "0.17.2"julia_library("Optim")
Make sure the Julia
installation is correct. JuliaCall
is able to
find Julia
on PATH, and there are three ways for JuliaCall
to find
Julia
not on PATH.
julia_setup(JULIA_HOME = "the folder that contains julia binary")
options(JULIA_HOME = "the folder that contains julia binary")
JULIA_HOME
in command line environment.julia$help
like the following example:julia_help("sqrt")#> ```#> sqrt(x)#> ```#>#> Return $\sqrt{x}$. Throws [`DomainError`](@ref) for negative [`Real`](@ref) arguments. Use complex negative arguments instead. The prefix operator `√` is equivalent to `sqrt`.#>#> # Examples#>#> ```jldoctest; filter = r"Stacktrace:(\n \[[0-9]+\].*)*"#> julia> sqrt(big(81))#> 9.0#>#> julia> sqrt(big(-81))#> ERROR: DomainError with -8.1e+01:#> NaN result for non-NaN input.#> Stacktrace:#> [1] sqrt(::BigFloat) at ./mpfr.jl:501#> [...]#>#> julia> sqrt(big(complex(-81)))#> 0.0 + 9.0im#> ```#>#> ```#> sqrt(A::AbstractMatrix)#> ```#>#> If `A` has no negative real eigenvalues, compute the principal matrix square root of `A`, that is the unique matrix $X$ with eigenvalues having positive real part such that $X^2 = A$. Otherwise, a nonprincipal square root is returned.#>#> If `A` is symmetric or Hermitian, its eigendecomposition ([`eigen`](@ref)) is used to compute the square root. Otherwise, the square root is determined by means of the Björck-Hammarling method [^BH83], which computes the complex Schur form ([`schur`](@ref)) and then the complex square root of the triangular factor.#>#> [^BH83]: Åke Björck and Sven Hammarling, "A Schur method for the square root of a matrix", Linear Algebra and its Applications, 52-53, 1983, 127-140. [doi:10.1016/0024-3795(83)80010-X](https://doi.org/10.1016/0024-3795(83)80010-X)#>#> # Examples#>#> ```jldoctest#> julia> A = [4 0; 0 4]#> 2×2 Array{Int64,2}:#> 4 0#> 0 4#>#> julia> sqrt(A)#> 2×2 Array{Float64,2}:#> 2.0 0.0#> 0.0 2.0#> ```
The GitHub Pages for this repository host the documentation for the
development version of JuliaCall
:
https://non-contradiction.github.io/JuliaCall/.
And you are more than welcome to contact me about JuliaCall
at
[email protected] or [email protected].
If you are interested in developing an R package which is an interface
for a Julia package, JuliaCall
is an ideal choice for that!
Basically you only need to find the Julia function or Julia module you
want to have in R
and then just using
the module and call
the
function. Several examples are:
diffeqr
is a package for
solving differential equations in R
. It utilizes
DifferentialEquations.jl for
its core routines to give high performance solving of ordinary
differential equations (ODEs), stochastic differential equations
(SDEs), delay differential equations (DDEs), and
differential-algebraic equations (DAEs) directly in R
.convexjlr
is an
R
package for Disciplined Convex Programming (DCP) by providing a
high level wrapper for Julia
package
Convex.jl
. convexjlr
can solve linear programs, second order cone programs, semidefinite
programs, exponential cone programs, mixed-integer linear programs,
and some other DCP-compliant convex programs through Convex.jl
.ipoptjlr
provides
an R
interface to the Ipopt
nonlinear optimization solver. It
provides a simple high-level wrapper for Julia
package
[Ipopt.jl
] (https://github.com/JuliaOpt/Ipopt.jl).JuliaCall
and Julia
package
MixedModels.jl
to
build mixed models in R
.autodiffr
provides automatic differentiation to native R
functions by
wrapping Julia
packages
ForwardDiff.jl
and
ReverseDiff.jl
through JuliaCall
, which is a work in progress.If you have any issues in developing an R
package using JuliaCall
,
you may report it using the link:
https://github.com/Non-Contradiction/JuliaCall/issues/new. Or email me
at [email protected] or [email protected].
JuliaCall
is under active development now. Any suggestion or issue
reporting is welcome! You may report it using the link:
https://github.com/Non-Contradiction/JuliaCall/issues/new. Or email me
at [email protected] or [email protected].
And if you encounter some issues which crash R
or RStudio
, then you
may have met segfault errors. I am very sorry. And I am trying my best
to remove errors like that. It will be much appreciated if you can
JuliaCall
from Github,JuliaCall.Rproj
in your RStudio or open R
from the
directory where you download the source of JuliaCall
,devtools::check()
to see the result of R CMD check
for
JuliaCall
on your machine,RCall.jl
is a Julia
package which embeds R
in Julia
. JuliaCall
is inspired by
RCall.jl
and depends on RCall.jl
for many functionalities like
much of the type conversion between R
and Julia
.XRJulia
is an R
package based on John Chambers’ XR
package and allow for
structured integration of R
with Julia
. It connects to Julia
and uses JSON to transfer data between Julia
and R
.RJulia
is an R
package
which embeds Julia
in R
as well as JuliaCall
. It is not on
CRAN yet and I haven’t tested it.JuliaObject
, which frees the JuliaObject
on the Julia
side
after it's freed on the R side.engine.path
option for Julia
in RMarkdown document.Julia
knitr
engine to avoid use of knitr
internal functions.Julia
stdout in RMarkdown documents.Julia
v0.7/1.0.Julia
v0.7.JuliaCall
is now compatible with RCall
v0.11.0 on Julia
v0.7.Pkg.build("RCall")
.Julia
v1.0.Julia
v0.7 and v1.0.JuliaCall
now should be usable on Julia
v0.7 and Julia
v1.0 with released version of RCall
.julia_source
on Julia
v0.7 and v1.0.julia_check
which is deprecated a long time ago.install
argument in julia_setup()
, setting it to FALSE
can reduce startup time
when no installation or checking of dependent Julia
packages is needed.julia_console()
.R6
dependency to reduce overhead creating JuliaObject
.Julia
v0.7,
currently need to use RCall#e59a546
with JuliaCall
on Julia
v0.7.Julia
v0.7.diff.JuliaObject
.JuliaObject
to that in native R.is.numeric
for JuliaObject
.c.JuliaObject
.install_dependency
not muted.julia_call
interface functions.sexp
, rcopy
and creation of JuliaObject
.julia$simple_call
interface which is a simple and more performant
"equivalent" of the julia_call
interface.JuliaCall
from Rcpp
.as.vector.JuliaObject
.as.double.JuliaObject
.JuliaObject
supports multiple index.mean
, determinant
and solve
generics for JuliaObject
.c
and t
generics for JuliaObject
.aperm
, dim<-
and as.vector
generics for JuliaObject
.julia_setup(verbose = TRUE)
.need_return
argument to julia_eval
, now there is a possibility to return
the result as an JuliaObject
, which is convenient for many use cases requiring
an R object corresponding to a julia object.JuliaObject
.rep.JuliaObject
.JuliaObject
.assign!
to match behavior for assign in R and use it for JuliaObject
.JuliaPlain
idea to alleviate the problem that R dispatches only on the first argument,
make ifelse
possible to work for JuliaObject
.JuliaCall
from julia and RCall.jl
.dim.JuliaObject
, is.array.JuliaObject
and is.matrix.JuliaObject
.autowrap
, which can generates automatic wrappers for julia
types.julia_docall
and julia_call
.JuliaObject
, especially in Rmd
documents. Fix #43.x$name
could be used to get access to field(x, name)
for JuliaObject
.RCall
checking.julia
issue #14577.JULIA_HOME
.julia_setup()
julia
engine in Rnw
files.JuliaCall
in rtichoke
.JuliaCall
requires Julia 0.6 as Julia 0.5 is now officially unmaintained.julia_setup()
any more,
accelerate the startup time.julia_setup
.julia_setup()
fails to correctly load libjulia.dll
if JULIA_HOME is not in path on windows.julia_eval_string
.JuliaCall
RMarkdown engine.
The display system should work for all kinds of documents that RMarkdown supports.JuliaObject
, for more detail, see github issue #15, issue #12 and #13 are related.JuliaObject
, and fix many small bugs.fields
, field
and field<-
function for JuliaObjects.JuliaObject
. It's lightweight, faster, and safer.plotsViewer()
, which integrates better into R.JuliaCall
, like removing deprecated functions.JuliaObject
, same Julia object could enter julia_object_dict only once.
And the display of JuliaObject
becomes better.
Also every common types of Julia Object could be wrapped by JuliaObject
.JuliaObject
type return value instead of
R Object.julia_call
interface.julia_eval_string
is deprecated in favor of julia_eval
.JuliaObject
, which serves as a proxy in R for julia object,
which is the automatic conversion target when other choices are not possible.julia_setup()
doesn't need to be called first unless you want to force
julia to restart or you need to set the julia path.julia.do_call
and julia_call
now accept keyword arguments.JuliaCall
works in Jupyter R notebook.JuliaCall
works in R Markdown.
The display system currently only work for html document.
When there is no return from julia function and there is a need to display,
a div with class=‘JuliaDisplay’ will be inserted into the html document
with the corresponding content.JuliaCall
.JuliaCall
is more consistent with julia.NEWS.md
file to track changes to the package.julia_assign
which can assign a value to a name in julia with automatic type conversion.julia_check
.julia_console
. Now there is a fully functional julia repl in R terminal,
and a usable julia console when you use IDE for R.julia_setup
, there is an option whether or not to use RCall.jl,
RCall's R REPL mode and rgui will be set correctly.julia_setup
for initial setup of JuliaCall
.julia_eval_string
, julia_command
for executing commands in julia.julia_do.call
and julia_call
for calling functions in julia.julia_help
.