**[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

Currently `Julia v0.6.x`

, `Julia v1.0.x`

, and `Julia v1.1`

are all supported by `JuliaCall`

.

You can get the development version of `JuliaCall`

by

Before using `JuliaCall`

, you need to do initial setup by function `julia_setup()`

for automatic type conversion, Julia display systems, etc. It is necessary for every new R session to use the package. If not carried out manually, it will be invoked automatically before other `julia_xxx`

functions. Solutions to some common error in `julia_setup()`

are documented in the troubleshooting section.

```
library(JuliaCall)
julia <- 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 `Julia` at a specific location, you could do the following:
## julia_setup(JULIA_HOME = "the folder that contains Julia binary").
## You can also set JULIA_HOME in command line environment or use `options(...)`.
## Different ways of using Julia to calculate sqrt(2)
# julia$command("a = sqrt(2);"); julia$eval("a")
julia_command("a = sqrt(2);"); julia_eval("a")
#> [1] 1.414214
julia_eval("sqrt(2)")
#> [1] 1.414214
julia_call("sqrt", 2)
#> [1] 1.414214
julia_eval("sqrt")(2)
#> [1] 1.414214
julia_assign("x", sqrt(2)); julia_eval("x")
#> [1] 1.414214
julia_assign("rsqrt", sqrt); julia_call("rsqrt", 2)
#> [1] 1.414214
2 %>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 not
julia_exists("sqrt")
#> [1] TRUE
julia_exists("c")
#> [1] FALSE
## Functions related to installing and using Julia packages
julia_install_package_if_needed("Optim")
julia_installed_package("Optim")
#> [1] "0.18.1"
julia_library("Optim")
```

Make sure the `Julia`

installation is correct. `JuliaCall`

can find `Julia`

on PATH, and there are three ways for `JuliaCall`

to find `Julia`

not on PATH.

- Use
`julia_setup(JULIA_HOME = "the folder that contains julia binary")`

- Use
`options(JULIA_HOME = "the folder that contains julia binary")`

- Set
`JULIA_HOME`

in command line environment.

Such problems are usually on Linux machines. The cause for the problem is that R cannot find the libstdc++ version needed by `Julia`

. To deal with the problem, users can export “TheFolderContainsJulia/lib/julia” to R_LD_LIBRARY_PATH.

The issue is usually caused by updates in R, and it can be typically solved by setting `rebuild`

argument to `TRUE`

in `julia_setup()`

as follows.

- One way to get help for Julia functions is just using
`julia$help`

as 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/.Also, you are more than welcome to contact me about

`JuliaCall`

at lch34677@gmail.com or cxl508@psu.edu.

If you are interested in developing an `R`

package which is an interface for a `Julia`

package, `JuliaCall`

is an ideal choice. You only need to find the `Julia`

function or `Julia`

module you want to have in `R`

, `using`

the module, and `julia_call`

the function. There are some examples:

`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).`FixedEffectjlr`

uses the`Julia`

package`FixedEffectModels.jl`

to estimate large fixed effects models in`R`

.- Julia MixedModels from R illustrates how to use
`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 lch34677@gmail.com or cxl508@psu.edu.

`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 lch34677@gmail.com or cxl508@psu.edu. You are welcome to use the issue template and the pull request template. The contributing guide provides some guidance for making contributions.

`JuliaCall`

PackageTo check and test the `JuliaCall`

package, you need to have the source package. You can

- download the source of
`JuliaCall`

from Github, - open
`JuliaCall.Rproj`

in your RStudio or open`R`

from the downloaded directory, - run
`devtools::test()`

to see the result of the test suite. - run
`devtools::check()`

or click the`Check`

button in the RStudio Build panel in the upper right to see the result of`R CMD check`

.

`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 type conversion between`R`

and`Julia`

.`XRJulia`

is an`R`

package based on John Chambers’`XR`

package and allows for structured integration of`R`

with`Julia`

. It connects to`Julia`

and uses JSON to transfer data between`Julia`

and`R`

. A simple performance comparison between`XRJulia`

and`Julia`

can be found in`JuliaCall`

JOSS paper.`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.

`JuliaCall`

is licensed under MIT.

Please note that the `JuliaCall`

project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

If you use `JuliaCall`

in research that resulted in publications, then please cite the `JuliaCall`

paper using the following BibTeX entry:

```
@Article{JuliaCall,
author = {Changcheng Li},
title = {{JuliaCall}: an {R} package for seamless integration between {R} and {Julia}},
journal = {The Journal of Open Source Software},
publisher = {The Open Journal},
year = {2019},
volume = {4},
number = {35},
pages = {1284},
doi = {10.21105/joss.01284},
}
```