jl4R: une vie polyamoureuse entre R et Julia

R(ulia) Drouilhet

`https://cqls.dyndoc.fr/jl4R/talk`

jl4R (obsolète) remplacé par Rulia, voir https://cqls.dyndoc.fr/Rulia/talk

►Introduction

►Pourquoi j'aime `R` et `julia`?

R: (single) dispatching, keyword arguments, simplicité, metaprgrammation, gestionnaire packages unique
julia: quasiment la même chose + performance (multiple dispatching, J.I.T. compilation, arbre des Types)

Le langage R (mes premiers amours de jeunesse 😂)

(single) dispatching (S3): comme une alternative (équivalente) à la programmation OOP, mettant en avant action/verbe
keyword arguments: paramètres nommés avec valeur par défaut équivalent à plusieurs fonctions en une seule fonction
simplicité: peu de structures de données et notion d'attribut
metaprogrammation: expressif puisque de type LISP (le code c'est de la donnée)
gestionnaire packages: unique

Le langage julia : digne successeur de R, un UNIQUE langage hybride R/C++

le triptyque:
1. multiple dispatching : action différente selon signature (pas seulement le premier argument)
2. Just In Time (J.I.T.) compilation
3. arbre des Types (toute variable a un type)
performance: rétablissement (direct et indirect) de la boucle for (à la C++)
expressivité:
1. metaprogrammation via système de macro
2. keyword arguments (hors signature)
gestionnaires packages: unique (basé sur le package Pkg.jl)

►Pourquoi le package `jl4R` (`julia` pour `R`)

une évidence (pour moi): julia un UNIQUE langage combinant expressivité du R et performance du C++
jl4R (alternative à JuliaCall) pour créer package R de type "wrapper" de package julia sans dépendance à Rcpp et RCall.jl (contrairement à JuliaCall)

Historique de jl4R

créé il y 10 ans environ (JuliaCall il y a 7ans), usage limité à communication entre vector R et Array julia
origine "remplacer Rcpp par julia" :
1. création de VirtualAgeModels.jl (package julia) inspirée par VAM (package R basé sur Rcpp)
2. une évidence: julia un UNIQUE langage combinant expressivité du R et performance du C++
intensification du développement du package jl4R :
- pour créer package R de type "wrapper" de package julia
- sans dépendance à Rcpp et RCall.jl (contrairement à JuliaCall)
- utilisateur R du "wrapper" pas besoin de connaître julia (comme pour Rcpp)

Objectif final de jl4R : VirtualAgeModelsJL en simulation

julia> using VirtualAgeModels
julia> m_sim = @vam(Time & Type ~ (ARA∞(0.4) | Weibull(.001,2.5)));
julia> df = rand(m_sim,100);
julia> first(df,5)
5×2 DataFrame
 Row │ Time      Type
     │ Float64   Int64
─────┼─────────────────
   1 │  5.87783     -1
   2 │ 19.9294      -1
   3 │ 25.5999      -1
   4 │ 30.5028      -1
   5 │ 30.5875      -1

R> require(VirtualAgeModelsJL)
R> m_sim = vam(Time & Type ~ (ARAInf(.4) | Weibull(.001,2.5)))
R> df = rand(m_sim,100)
R> head(df)
      Time Type
1 11.45393   -1
2 26.78059   -1
3 27.75529   -1
4 36.41756   -1
5 41.22767   -1
6 54.27561   -1

Objectif final de jl4R : VirtualAgeModelsJL en estimation MLE

julia> using VirtualAgeModels
julia> m_mle = @vam(Time & Type ~ (ARA∞(0.4) | Weibull(.001,2.5)));
julia> mle(m_mle, df);
julia> params(m_mle)
3-element Vector{Float64}:
 0.001
 2.6102623440166473
 0.33550975279136264

R> require(VirtualAgeModelsJL)
R> m_mle = vam(Time & Type ~ (ARAInf(.4) | Weibull(.001,2.5)))
R> mle(m_mle, data = df)
3-element Vector{Float64}:
 0.001
 2.425609861033199
 0.3720243399410744
R> params(m_mle)
3-element Vector{Float64}:
 0.001
 2.425609861033199
 0.3720243399410744

►`jl4R` (`julia` for `R`)

►Utilisation de `jl4R`

Workflow
1. Création fonction(s) julia
2. Appel de fonction(s) julia en R
3. 3 modes d'utilisation:
  - mode "unsafe" jlvalue
  - mode "safe" jl
  - mode "safe" plus expressif jl+

Utilisation du package jl4R

Worflow étape 1: Création fonction(s) julia via au choix :
1. création package julia (puis dans R, jlusing(_package_))
2. création fichier julia (puis dans R, jlinclude(_fichier_))
3. création "inline" (à la Rcpp) directement dans R (dans R, jl(_julia_code_))
Worflow étape 2: Appel fonction(s) julia dans R
1. conversion R -> julia (via jl(_objet_R_) ou jlvalue(_objet_R_)
2. appel fonction julia dans R (via jl(_julia_function_)(...))
3. conversion julia -> R (via R(_jlvalue_object_))

Les 3 modes d'utilisation de jl4R

mode jlvalue ("unsafe"):
- conversions jlvalue() et fonctions jlvalue_...():
- moins sûr car proche des API C du R et julia
- plutôt à un utiliser en mode développeur (on sait ce l'on fait)
mode jl (basique mais "safe") :
- a priori "safe" car utilisation système d'exception (try/catch)
- principales fonctions: jleval() et jlcall()
mode jl+ (plus élaboré et "safe") :
- uniquement: un environnement jl et une fonction jl()
- objectifs avoués :
  - format le plus similaire au code original julia
  - pas (ou peu) de chaînes de caractères pour appel de fonction julia

1. Code julia (mode jl+)

julia> [1,3,4]
3-element Vector{Int64}:
 1
 3
 4
julia> VERSION
v"1.9.3"

R> jl(`[1,3,4]`)
3-element Vector{Int64}:
 1
 3
 4
R> jl(VERSION) # ou jl(`VERSION`)
v"1.9.3"

1. Code julia (mode jl)

julia> [1,3,4]
3-element Vector{Int64}:
 1
 3
 4
julia> VERSION
v"1.9.3"

R> jleval("[1,3,4]")
3-element Vector{Int64}:
 1
 3
 4
R> jleval("VERSION")
v"1.9.3"

1. Code julia (mode jlvalue)

julia> [1,3,4]
3-element Vector{Int64}:
 1
 3
 4
julia> VERSION
v"1.9.3"

R> jlvalue_eval("[1,3,4]")
3-element Vector{Int64}:
 1
 3
 4
R> jlvalue_eval("VERSION")
v"1.9.3"

2. Code julia multilignes (mode jl+)

julia> f(x,y) = x + y
f (generic function with 1 method)
julia> (f(2,3), f(1.0,3))
(5, 4.0)

R> jl(`
+ f(x,y) = x + y
+ (f(2,3), f(1.0,3))
+ `)
(5, 4.0)

2. Code julia multilignes (mode jl)

julia> f(x,y) = x + y
f (generic function with 1 method)
julia> (f(2,3), f(1.0,3))
(5, 4.0)

R> jleval("
+ f(x,y) = x + y
+ (f(2,3), f(1.0,3))
+ ")
(5, 4.0)

2. Code julia multilignes (mode jlvalue)

julia> f(x,y) = x + y
f (generic function with 1 method)
julia> (f(2,3), f(1.0,3))
(5, 4.0)

R> jlvalue_eval("
+ f(x,y) = x + y
+ (f(2,3), f(1.0,3))
+ ")
(5, 4.0)

3. Conversion (basique) R -> julia (mode jl+)

julia> t = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof.(t)
(Bool, Int64, Float64, String)

R> jl(TRUE)
true
R> jl(1L)
1
R> jl(1)
1.0
R> jl("1.0")
"1.0"

3. Conversion (basique) R -> julia (mode jlvalue)

julia> t = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof.(t)
(Bool, Int64, Float64, String)

R> jlvalue(TRUE)
true
R> jlvalue(1L)
1
R> jlvalue(1)
1.0
R> jlvalue("1.0")
"1.0"

4. Conversion (vecteur) R -> julia (mode jl+)

julia> a  = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof(a)
Tuple{Bool, Int64, Float64, String}

R> jl(c(TRUE, 1L, 1, "1.0"))
4-element Vector{String}:
 "TRUE"
 "1"
 "1"
 "1.0"
R> jl(list(TRUE, 1L, 1, "1.0"))
(true, 1, 1.0, "1.0")

4. Conversion (vecteur) R -> julia (mode jlvalue)

julia> a  = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof(a)
Tuple{Bool, Int64, Float64, String}

R> jlvalue(c(TRUE, 1L, 1, "1.0"))
4-element Vector{String}:
 "TRUE"
 "1"
 "1"
 "1.0"
R> jlvalue(list(TRUE, 1L, 1, "1.0"))
(true, 1, 1.0, "1.0")

5. Variables julia dans R (mode jl+)

julia> a  = [true, 1, 1.0, "1.0"]
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
julia> typeof(a)
Vector{Any} (alias for Array{Any, 1})
julia> b  = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof(b)
Tuple{Bool, Int64, Float64, String}

R> ## Native julia objects
R> jl$a <- jl(`[true, 1, 1.0, "1.0"]`)
R> jl$a
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
R> jl$b <- jl(`(true, 1, 1.0, "1.0")`)
R> jl$b
(true, 1, 1.0, "1.0")
R> ## with conversion R -> julia
R> jl$b2 <- list(TRUE, 1L, 1, "1.0")
R> jl$b2
(true, 1, 1.0, "1.0")

5. Variables julia dans R (mode jl)

julia> a  = [true, 1, 1.0, "1.0"]
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
julia> typeof(a)
Vector{Any} (alias for Array{Any, 1})
julia> b  = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof(b)
Tuple{Bool, Int64, Float64, String}

R> jleval('a =[true, 1, 1.0, "1.0"]')
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
R> jleval('a')
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
R> jleval('b = (true, 1, 1.0, "1.0")')
(true, 1, 1.0, "1.0")
R> jleval('b')
(true, 1, 1.0, "1.0")
R> ## error below don't crash
R> jleval('b = (true, 1, 1.0, "1.0"')
Julia Exception: ErrorException

5. Variables julia dans R (mode jlvalue)

julia> a  = [true, 1, 1.0, "1.0"]
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
julia> typeof(a)
Vector{Any} (alias for Array{Any, 1})
julia> b  = (true, 1, 1.0, "1.0")
(true, 1, 1.0, "1.0")
julia> typeof(b)
Tuple{Bool, Int64, Float64, String}

R> jlvalue_eval('a =[true, 1, 1.0, "1.0"]')
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
R> jlvalue_eval('a')
4-element Vector{Any}:
 true
    1
    1.0
     "1.0"
R> jlvalue_eval('b = (true, 1, 1.0, "1.0")')
(true, 1, 1.0, "1.0")
R> jlvalue_eval('b')
(true, 1, 1.0, "1.0")
R> ## error below will crash badly
R> # jlvalue_eval('b = (true, 1, 1.0, "1.0"')

6. Appel fonction julia dans R (mode jl+)

julia> sum
sum (generic function with 11 methods)
julia> typeof(sum)
typeof(sum) (singleton type of function sum, subtype of Function)
julia> sum([1,3,2])
6
julia> sum([1,3,2], init=4)
10
julia> isa(sum,Function)
true
julia> sum isa Function
true

R> jl(sum)
sum (generic function with 11 methods)
R> class(jl(sum))
[1] "jlfunction"
R> jl(typeof)(sum)
typeof(sum) (singleton type of function sum, subtype of Function)
R> jl(sum)(`[1,3,2]`)
6
R> jl(sum)(c(1,3,2))
6.0
R> jl(sum)(c(1,3,2), init=4)
10.0
R> jl(isa)( `sum`,`Function`)
true
R> jl(isa)(sum,Function)
true

6. Appel fonction julia dans R (mode jl)

julia> sum
sum (generic function with 11 methods)
julia> typeof(sum)
typeof(sum) (singleton type of function sum, subtype of Function)
julia> sum([1,3,2])
6
julia> sum([1,3,2], init=4)
10
julia> isa(sum,Function)
true
julia> sum isa Function
true

R> jleval("sum")
sum (generic function with 11 methods)
R> jleval("typeof(sum)")
typeof(sum) (singleton type of function sum, subtype of Function)
R> jlcall("sum", jleval("[1,3,2]"))
6
R> jlcall("sum", c(1,3,2), init=4)
10.0
R> jlcall("isa", jleval("sum"),jleval("Function"))
true
R> jleval("sum isa Function")
true

6. Appel fonction julia dans R (mode jlvalue)

julia> sum
sum (generic function with 11 methods)
julia> typeof(sum)
typeof(sum) (singleton type of function sum, subtype of Function)
julia> sum([1,3,2])
6
julia> sum([1,3,2], init=4)
10
julia> isa(sum,Function)
true
julia> sum isa Function
true

R> jlvalue_eval("sum")
sum (generic function with 11 methods)
R> jlvalue_eval("typeof(sum)")
typeof(sum) (singleton type of function sum, subtype of Function)
R> jlvalue_call("sum",jlvalue_eval("[1,3,2]"))
6
R> ## Not possible: jlvalue_call("sum", jlvalue([1,3,2]), init=4)")
R> jlvalue_eval("isa(sum,Function)")
true
R> jlvalue_eval("sum isa Function")
true

7. Conversion julia -> R

R> jl$a <- jl(`[1,3,2]`)
R> R(jl$a)
[1] 1 3 2
R> jl(sum)(jl$a)
6
R> jl(sum)(a)
6
R> R(jl(sum)(jl$a))
[1] 6
R> R(jlcall("sum", c(1,3,2), init=4))
[1] 10