Comenzando¶
La instalación de Julia es directa, sea utilizando archivos binários pre-compilados, sea compilando el código-fuente. Descargue e instale Julia siguiendo las instrucciones (em inglés) en http://julialang.org/downloads/.
La manera más facil de aprender y experimentar con Julia es iniciando una sesión interactiva (também conecida como read-eval-print loop ou “repl” [1]):
$ julia
_
_ _ _(_)_ |
(_) | (_) (_) | A fresh approach to technical computing.
_ _ _| |_ __ _ |
| | | | | | |/ _` | | Version 0 (pre-release)
| | |_| | | | (_| | | Commit 61847c5aa7 (2011-08-20 06:11:31)*
_/ |\__'_|_|_|\__'_| |
|__/ |
julia> 1 + 2
3
julia> ans
3
Para cerrar la sesión interactiva, digite ^D`
- la tecla Ctrl
en conjunto la tecla d
- o digite quit()
. Cuando utilize
Julia en modo interativo, julia
muestra un banner y espera al
usuário que digite un comando. Una vez que el usuário digitó el comando,
como 1 + 2, y presione enter, la sesión interativa calcula la
expresión y muestra el resultado. Si una expresión es insertada en una
sesión interativa con un punto y coma al final, su resultado será
calculado, pero no será mostrado. La varible ans
almacena el resultado
de la última expresión calculada, después de haber sido mostrado o no.
Para calcular expresiones escritas en un archivo file.jl
, luego digite
include("file.jl")
.
Para rodar código en un archivo de manera no-interactiva, puede pasar el nombre del archivo como el primer argumento en la llamada de Julia:
$ julia script.jl arg1 arg2...
Como muestra el ejemplo, los argumentos de la línea de comando subsequentes
son tomados como argumentos para el programa script.jl
, pasado en la
constante global ARGS
. ARGS
es también definida cuando el código
del script es dado usando la opción de la linea de comando -e
(vea la
salida de ayuda de julia
abajo). Por ejemplo, para apenas imprimir
los argumentos dados a un script, ustedes puede hacer:
$ julia -e 'for x in ARGS; println(x); end' foo bar
foo
bar
O puede colocar dicho código en un script y ejecutarlo:
$ echo 'for x in ARGS; println(x); end' > script.jl
$ julia script.jl foo bar
foo
bar
Hay varias formas de llamar a Julia y pasar opciones, semejantes
a aquellas disponibles para los programas perl
y ruby
:
julia [options] [program] [args...]
-v --version Muestra información de la versión
-q --quiet Quiet startup without banner
-H --home=<dir> Load files relative to <dir>
-T --tab=<size> Set REPL tab width to <size>
-e --eval=<expr> Evaluar <expr>
-E --print=<expr> Evaluar y mostrar <expr>
-P --post-boot=<expr> Evaluate <expr> right after boot
-L --load=file Load <file> right after boot
-J --sysimage=file Start up with the given system image file
-p n Run n local processes
--machinefile file Run processes on hosts listed in file
--no-history Don't load or save history
-f --no-startup Don't load ~/.juliarc.jl
-F Load ~/.juliarc.jl, then handle remaining inputs
-h --help Imprimir este mensaje
Tutorial¶
Algunas guias paso a paso están disponibles online:
Diferencias notables en relación al MATLAB¶
Usuarios de MATLAB pueden encontrar una sintaxis familiar en Julia, pero no es de ninguna manera un clon de MATLAB: hay grandes diferencias sintácticas y funcionales. A continuación se presentan algunas advertencias importantes que puedan confundir a los usuarios Julia acostumbrados con MATLAB:
- Arrays son indexados con corchetes,
A[i,j]
. - La unidad imaginaria
sqrt(-1)
es representada en Julia porim
. - Múltiples valores son devueltos y asignados con paréntesis,
return (a, b)
e(a, b) = f(x)
. - Los valores se transmiten y se asignan por referencia. Si una función modifica un array, los cambios serán visibles para quien llamó.
- Julia tiene arrays unidimensionales. Vectores-columna son de tamaño
N
, nãoNx1
. Por ejemplo,rand(N)
crea un array unidimensional. - Concatenar escalares y arrays con una sintaxis
[x,y,z]
concatena la primera dimensión (“verticalmente”). Para la segunda dimensión, (“horizontalmente”), use espacios, como en[x y z]
. Para construir matrices en bloques (concatenando las dos primeras dimensiones), es usada una sintaxis[a b; c d]
para evitar confusión. - Dos-puntos
a:b
ea:b:c
construyen objetosRange
. Para construir un vector completo, uselinspace
, o “concatene” o en el intervalo colocando en corchetes,[a:b]
. - Funciones devuelven valores usando a palavra-clave
return
, en vez de colocar citas a sus nombres en la definición de la función (vea The “return” Keyword para mas detalles). - Un archivo puede almacenar un número cualquiera de funciones, y todas las definiciones van a ser visibles para fuera cuando el archivo fuera cargado.
- Reducciones como
sum
,prod
, emax
son hechas sobre cada elemento de un array cuando son llamadas con un único argumento, como ensum(A)
. - Funciones como
sort
que operan de forma estándar en columnas (sort(A)
es equivalente asort(A,1)
) no poseen un comportamiento especial para arrays 1xN; el argumento es retornado inalterado, ya que la operación hecha fuesort(A,1)
. Para ordenar una matriz 1xN como un vector, usesort(A,2)
. - Paréntesis deben ser usados para llamar una función con cero
argumentos, como en``tic()`` y
toc()
. - No use punto y coma para cerrar declaraciones. Los resultados
de declaraciones no son automáticamente impresos (exceto no prompt
interativo), y lineas de código no precisan terminar con
punto y coma. A función
println
puede ser usada para imprimir un valor seguido de una nueva línea. - Si
A
eB
são arrays,A == B
no devuelve un array de booleanos. UseA .== B
. Lo mismo es válido para otros operadores booleanos,<
,>
,!=
, etc. - Los elementos de uma colección pueden ser passados como argumentos para
una función usando
...
, como enxs=[1,2]; f(xs...)
. - La función
svd
de Julia retorna los valores singulares como un vector, y no como uma matriz diagonal.
Diferencias notables en relación al R¶
Uno de los objetivos de Julia es proporcionar un lenguaje eficaz para el análisis de datos y programación estadística. Para los usuarios de Julia procedentes R, estas son algunas diferencias importantes:
Julia usa
=
para atrbuit. Julia proporciona ningún otro operador alternativo, como<-
o<-
.Julia construye vectores usando corchetes. O
[1, 2, 3]
de Julia es equivalente ac(1, 2, 3)
del R.Las operaciones con matrices en Julia son más afines a la notación matemática tradicional que los del R. Si
A
eB
son matrices, entoncesA * B
define una multiplicación de matrices en Julia equivalente aA %*% B
de R. En R, esta notación haría un producto de Hadamard (elemento a elemento). Para la multiplicación elemento a elemento em Julia, usted debe escribirA .* B
.Julia transpone matrices utilizando el operador
'
. ElA'
en Julia es entonces equivalente at(A)
del R.Julia no requiere paréntesis al escribir condiciones
if
o loopsfor
: usefor i in [1, 2, 3]
en lugar defor (i in c(1, 2, 3))
yif i == 1
en lugar deif (i == 1)
.Julia no trata los números
0
e1
como booleanos. No puede escribirif (1)
en Julia, porque condicionesif` solo aceptan booleanos. En lugar, escriba ``if true
.Julia no proporciona funciones
nrow
yncol
. Usarsize(M, 1)
en lugar denrow(M)
esize(M, 2)
en lugar dencol(M)
.La SVD de Julia no se reduce de forma predeterminada, a diferencia deR. Para obtener resultados similares a los de R, debe llamar a
svd(X, true)
en una matrizX
.Julia es un lenguaje muy prudente en distinguir escalar, vectores y matrices. En R,
1
yc(1)
son iguales. En Julia, no se pueden utilizar en el lugar de otro. Una consecuencia potencialmente confuso es quex' * y
para vectoresx
yy
es un vector de un elemento, y no un escalar. Para obtener un escalar, puede usardot(x, y)
.Las funciones
diag()
ydiagm()
de Julia no son parecidas con las del R.Julia no puede asignar los resultados de las llamadas de función en el lado izquierdo de una operación: no puede escribir
diag(M) = ones(n)
Julia desincentiva al popular namespace principal con funciones. La mayor parte de las funcionalidades estadísticas para Julia es encontrada en paquetes como el DataFrames y Distributions.
- Funciones de distribuciones son encontradas en el paquete Distributions
- El paquete DataFrames pruebe data frames.
- Fórmulas para GLM deben ser escapadas: use
:(y ~ x)
en lugar dey ~ x
.
Julia proporciona tuplas y tablas de dispersión reales, pero las listas de R. Cuando tenga que devolver varios elementos, típicamente debe usar una tupla: en lugar de
list(a = 1, b = 2)
, use(1, 2)
.Julia invita a los usuarios a escribir sus propios tipos. Los tipos de Julia son bien mas fáciles de usar de que los objetos S3 o S4 de R. El sistema de multiple dispatch de Julia significa que
table(x::TypeA)
ytable(x::TypeB)
actúan comotable.TypeA(x)
ytable.TypeB(x)
en R.En Julia, valores son pasados y atribuídos por referencia. Se una función modifica un array, las modificaciones serán visibles en lugar de la llamada. Ese comportamiento es bien diferente en el R, y permite que nuevas funciones operen en grandes estructuras de datos de manera mucho mas eficiente.
Concatenación de vectores y matrices se realiza utilizando
hcat
yvcat
, noc
,rbind
ycbind
.Un objeto
Range
a:b
en Julia no es una forma abreviada de un vector como en R, pero si un tipo especializado de objeto que es utilizado para iteración sin tener que gastar una gran cantidad de memoria. Para convertir unRange
en un vector, es necesario rodearlo con corchetes:[a:b]
.Julia tiene varias funciones que pueden modificar sus argumentos. Por ejemplo, hay tanto
sort(v)
comosort!(v)
.En R, eficiencia requiere vectorización. En Julia, casi lo contrario es cierto: el código mas eficiente es a menudo desvetorizado.
A diferencia de R, no hay una evaluación perezosa [2] [3] en Julia. Para la mayoría de los usuarios, ello significa que hay pocas expresiones o nombres de columna sin las comillas..
Julia no posee un tipo
NULL
.No hay un equivalente de
assign
oget
de R en Julia.
Notas al pie
[1] | http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop |
[2] | http://pt.wikipedia.org/wiki/Avalia%C3%A7%C3%A3o_pregui%C3%A7osa |
[3] | http://en.wikipedia.org/wiki/Lazy_evaluation |