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,
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!
Hola,
Además del algoritmo de cálculo, está el que han usado la versión 2.9.0, y desde la 2.13.0 ha habido mejoras sustanciales de velocidad. También se podría haber probado con la versión de Revolution Analytics por confirmar que efectivamente da un poco más que la oficial.
También Google, cuida de R… :-).
http://romainfrancois.blog.free.fr/index.php?post/2011/11/26/int64:-64-bit-integer-vectors-for-R
@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».
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.
http://www.skytreecorp.com/
Que opinan de esta clasificación de las diferentes herramientas?
http://www.thedatascientist.com/2011/07/22/essential-tools-for-a-data-scientist/
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 😉