Julia, un nuevo lenguaje para la programación científica

Carlos J. Gil Bellosta 7 comentarios

No sé si conocéis Julia, un lenguaje de programación orientado al cálculo científico. Os dejaré echarle un vistazo a su página.

¿Ya?

Bueno, pues estoy un poco enfadado con ellos. Me pasa un poco como a los catalanes que se quejaban de que en las fotos de ABC siempre sacaban a Jordi Pujol (todavía más) feo (de lo que por sí era): en las comparaciones no le hacen excesiva justicia a R. Me he tomado la molestia de reescribir el código para una de las comparaciones que realizan, pi_sum, utilizando código vectorizado.

El original es

library(R.utils)
 
assert = function(bool) {
    if (!bool) stop('Assertion failed')
}
 
timeit = function(name, f, ..., times=5) {
    tmin = Inf
    for (t in 1:times) {
        t = system.time(f(...))["elapsed"]
        if (t < tmin) tmin = t
    }
    cat(sprintf("r,%s,%.8f\n", name, tmin*1000))
}
 
pisum = function() {
    t = 0.0
    for (j in 1:500) {
        t = 0.0
        for (k in 1:10000) {
            t = t + 1.0/(k*k)
        }
    }
    return(t)
}
 
assert(abs(pisum()-1.644834071848065) < 1e-12);
timeit("pi_sum", pisum, times=1)

y tarda 10760 milisegundos en mi máquina.

El código alternativo,

pisum.cjgb <- function() {
    for (j in 1:500) 
        t <- sum( (1:10000)^(-2) )
    return(t)
}
 
assert(abs(pisum.cjgb()-1.644834071848065) < 1e-12);
timeit("pi_sum_cjgb", pisum.cjgb, times=1)

tarda 510 milisegundos, veinte veces menos.

En cualquier caso, me viene sorprendiendo mucho la velocidad de JavaScript. ¿Recordáis mi entrada sobre las ocho reinas? La versión en JavaScript,


<body onload="javascript:cnt=0;

function backTrack(trial,next){
if (trial.length==0){return true;}
else {
for (var i in trial){
if (Math.abs(trial.length-i)==Math.abs(next-trial[i])){
return false;
}
}
return true;
}
}

function perm(p,l){
if (l.length==0){
cnt++;document.write(cnt+'::'+p+'<br/>')
}
else {
for (var i in l){
if (backTrack(p,l[i])){
perm( p.concat(l[i]),
l.slice(0,l.indexOf(l[i])).concat(l.slice(l.indexOf(l[i])+1,l.length))
);
}
}
}
}

perm([],[1,2,3,4,5,6,7,8,9,10,11])">

</body>

(cópiese el código anterior en un fichero loquesea.html y ábrase en el navegador) es notablemente más rápido que el equivalente en R.

¡Supongo que hay mucha más gente optimizando JavaScript —que, al fin y al cabo, es el instrumento que usa Google para entrar a tu cocina— que R!

Enlaces relacionados:

  1. rJython: un nuevo paquete para llamar a Python desde R
  2. RStudio, un nuevo editor multiplataforma para R
  3. Para que copien, peguen y disfruten

7 comentarios sobre “Julia, un nuevo lenguaje para la programación científica”

  2. datanalytics 28 febrero, 2012 23:45

    @Carlos Ortega Efectivamente, es bastante vieja la comparación. Y algo injusta porque la versión de R es del 2009 y la de Matlab es de 2011, por ejemplo.

    No obstante, la ventaja que aún parece sacarle JavaScript a R en muchos aspectos no deja de ser sorprendente. Y el mismo Ross Ithaka, en http://www.stat.auckland.ac.nz/~ihaka/downloads/JSM-2010.pdf se plantea la posibilidad de pasar (la hoja de R) y crear un lenguaje para la computación estadística sobre otro (tal vez de propósito general) de la que la comunidad estadística herede las optimizaciones realizadas por otras más amplias «for free».

  3. Enrique Gabriel Baquela 29 febrero, 2012 0:48

    Las comparativas entre implementaciones en diferentes lenguajes siempre son un poco injustas, dependen que tan hábil sean los programadores en sendos lenguajes. Igualmente Julia parece un buen lenguaje.
    Lo que si, la velocidad de Javascript es sorprendente.

  6. Pingback: datanalytics » Más sobre Julia
  7. diego 11 enero, 2013 18:49

    Acabo de testear esa versión de pi_sum (la segunda en este post) en mi compu y comparé con la versión de pi_sum en Julia…

    en R 2.15 [ con library(«compiler»);enableJIT(3) ]:
    > timeit(«pi_sum», pisum)
    r,pi_sum,523.00000000
    > timeit(«pi_sum_cjgb», pisum.cjgb)
    r,pi_sum_cjgb,313.00000000

    en Julia 0.0:
    julia> @timeit pisum() «pi_sum»
    julia,pi_sum,17.96889305114746

    Julia al parecer es más rápido que R, aun cuando uno optimiza un poco mas el código 😉

Los comentarios están desabilitados.