Ligando R e Julia?

Julia parece muito promissora para uma computação rápida e com boa sintaxe (por exemplo, aqui ), mas eu suspeito que não chegará nem perto de R em termos de fluxo de trabalho estatístico geral por algum tempo ainda. Então, eu gostaria de usá-lo onde o C ++ é usado principalmente em programas R: para otimizar porções lentas do código. Antes de investir tempo em aprender Julia, porém, estou curioso para saber quais são as facilidades para incorporar trechos de Julia no código R.

Assim:

• Que facilidades existem para ligar R e Julia?
• Quão robustos e bem pensados ​​eles são, numa escala de zero a Rcpp?

Quero chamar Julia de R, assim como o Rcpp permite chamar C ++ de dentro de R agora. Não quero ligar para R da Julia. (Portanto, RCall.jl não funcionaria)

O pacote RJulia R parece muito bom agora, da R., R CMD checké executado sem avisos ou erros (se juliaestiver instalado corretamente).

O maior TODO, na minha opinião, é fazer com que Julia retorne listas nomeadas que constituem a estrutura de dados gerais flexível realmente básica em R.

Observe que Doug Bates me alertou sobre o RCall de uma interface bidirecional de Julia para R (ou seja, a outra direção que não R para Julia). Além disso, Doug recomendou segmentar o julia 0.4.0 em vez das versões estáveis ​​atuais do julia.

Eu também olho para Julia desde que Doug Bates me enviou um alerta em janeiro . Mas, como @ gsk3, eu medi isso em uma "escala Rcpp", pois gostaria de passar objetos R ricos para Julia. E isso não parece ser suportado de momento.

Julia tem uma interface C agradável e simples. Então isso nos dá algo parecido .C(). Mas, como discutido recentemente no r-devel, você realmente não deseja .C(); na maioria dos casos, prefere .Call()passar variáveis ​​SEXP reais que representam objetos R reais. Então, neste momento, vejo pouco espaço para Julia de R por causa dessa limitação.

Talvez uma interface indireta usando tcp / ip para Rserve possa ser a primeira partida antes que Julia amadureça um pouco e tenhamos uma interface C ++ adequada. Ou usamos algo baseado em Rcpp para ir de R para C ++ antes de inserir uma camada intermediária [que alguém teria que escrever] a partir da qual alimentamos os dados para Julia, assim como a API R real oferece apenas uma camada C. Não sei.

E no final do dia, pode ser necessária alguma paciência. Comecei a olhar para o R por volta de 1996 ou 1997, quando Fritz Leisch fez os primeiros anúncios no grupo de notícias comp.os.linux.announce. E R tinha instalações bastante limitadas na época (mas a promessa completa da língua S, é claro, se soubéssemos que tínhamos um vencedor). E alguns anos depois eu estava pronto para torná-la minha principal linguagem de modelagem. Naquela época, o CRAN ainda tinha menos de 100 pacotes ...

Julia pode muito bem chegar lá. Mas, por enquanto, suspeito que muitos de nós farão o trabalho em R e tenham apenas alguns vislumbres curiosos em Julia.

O plano de desenvolvimento da Julia, como descrevi nesta resposta, é permitir a compilação do código da Julia em bibliotecas compartilhadas, chamadas através da C ABI. Quando isso acontecer, será mais fácil chamar o código Julia do R do que chamar o código C / C ++. Há, no entanto, uma quantidade razoável de trabalho necessário antes que isso se torne possível.

Uma atualização rápida. Desde que essa pergunta foi feita, houve o início de um pacote Julia que permite chamar programas R a partir de Julia.

Mais aqui: https://github.com/lgautier/Rif.jl

Alguém viu esse projeto?

https://github.com/armgong/RJulia

Bastante novo, mas parece estar fazendo exatamente o que é solicitado!

Crio um pacote R chamado JuliaCallrecentemente, que incorpora Julia em R. O pacote está no CRAN.

https://cran.r-project.org/web/packages/JuliaCall/index.html

https://github.com/Non-Contradiction/JuliaCall

O uso do pacote é assim:

library(JuliaCall)
julia <- julia_setup()
julia_command("a = sqrt(2)"); julia_eval("a")
julia_eval("sqrt(2)")
julia_call("sqrt", 2)
julia_eval("sqrt")(2)

Como você pode ver, você pode enviar seqüências de comando e chamar funções de Julia com muita facilidade.

E há também alguns pacotes R envolvendo pacotes Julia usando JuliaCall, por exemplo,

• convexjlr para programação convexa disciplinada em R usando o Convex.jl, que também está no CRAN.
• ipoptjlr, uma interface R para o Interior Point OPTimizer (IPOPT) usando o pacote Julia Ipopt.jl.

Bem-vindo para qualquer feedback sobre JuliaCall!!

Há também o pacote XRJulia da família de pacotes XR com o objetivo de e X tender R por John Chambers (um dos criadores do R). Ele usa uma abordagem um pouco diferente (JSON) para transferir dados entre Julia e R, em seguida, rJulia e pacotes similares.

Você também pode querer conferir minha tentativa: O JuliaConnectoRpacote R. O pacote está disponível no GitHub e CRAN .

Seu objetivo é importar funções da Julia diretamente no R, para que possam ser usadas como funções R no código R. Os valores de retorno das funções de Julia são convertidos para estruturas de dados R, que podem ser usadas em R e também passadas de volta para Julia. Para uma integração adicional de Julia e R, também é possível retornar a chamada de Julia para R passando funções R como funções de retorno de chamada.

Semelhante ao XRJulia, o JuliaConnectoR conta com o TCP, mas é funcionalmente orientado e usa um formato de fluxo personalizado otimizado em vez de mensagens JSON baseadas em texto, como o XRJulia. Uma vantagem da comunicação pelo TCP é a estabilidade em relação às diferentes versões de Julia e R. Isso é muito mais difícil de manter com uma integração no nível das interfaces C, como RCall e JuliaCall.

O pacote funciona com Julia ≥ 1.0 e uma ampla variedade de versões R.