Começando¶
A instalação de Julia é direta, seja com utilizando binário pré-compilados, seja compilando o código-fonte. Baixe e instale Julia seguindo as instruções (em inglês) em http://julialang.org/downloads/.
A maneira mais fácil de aprender e experimentar com Julia é iniciando sessão interativa (também conhecida 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 encerrar a sessão interative, digite ^D`
- a tecla Ctrl
em conjunto da tecla d
- ou digite quit()
. Quando utilizando
Julia no modo interativo, julia
mostra um banner e espera o
usuário digitar um comando. Uma vez que o usuário digitou comando,
como 1 + 2, e pressionou enter, a sessão interativa calcula a
expressão e mostra o resultado. Se uma expressão é inserida em uma
sessão interativa com um ponto-e-vírgula no final, seu resultado será
calculado, mas não mostrado. A variável ans
armazena o resultado
da última expressão calculada, tendo sido mostrada ou não.
Para calcular expressões escritas em um arquivo file.jl
, digite
include("file.jl")
.
Para rodar código em um arquivo de maneira não-interativa, você pode passar o nome do arquivo como o primeiro argumento na chamada de Julia:
$ julia script.jl arg1 arg2...
Como mostra o exemplo, os argumentos da linha de comando subsequentes
são tomados como argumentos para o programa script.jl
, passados na
constante global ARGS
. ARGS
é também definida quando o código
do script é dado usando a opção da linha de comando -e
(veja a
saída de ajuda de julia
abaixo). Por exemplo, para apenas imprimir
os argumentos dados a um script, você pode fazer:
$ julia -e 'for x in ARGS; println(x); end' foo bar
foo
bar
Ou pode colocar esse código em um script e rodá-lo:
$ echo 'for x in ARGS; println(x); end' > script.jl
$ julia script.jl foo bar
foo
bar
Há várias maneiras de chamar Julia e passar opções, semelhantes
àquelas disponívels para os programas perl
e ruby
:
julia [options] [program] [args...]
-v --version Display version information
-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> Evaluate <expr>
-E --print=<expr> Evaluate and show <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 Print this message
Tutoriais¶
Alguns guias passo-a-passo estão disponíveis online:
Diferenças nótáveis em relação ao MATLAB¶
Usuários de MATLAB podem achar a sintaxe de Julia familar, porém Julia não é de maneira alguma um clone de MATLAB: há grandes diferenças sintáticas e funcionais. Apresentadas a seguir estão algumas importantes ressalvas que podem confundir usuários de Julia acostumados com MATLAB:
- Arrays são indexados com colchetes,
A[i,j]
. - A unidade imaginária
sqrt(-1)
é representada em Julia porim
. - Múltiplos valores são retornados e atribuídos com parênteses,
return (a, b)
e(a, b) = f(x)
. - Valores são passados e atribuídos por referência. Se uma função modifica um array, as mudanças serão visíveis para quem chamou.
- Julia tem arrays unidimensionais. Vetores-coluna são de tamanho
N
, nãoNx1
. Por exemplo,rand(N)
cria um array unidimensional. - Concatenar escalares e arrays com a sintaxe
[x,y,z]
concatena na primeira dimensão (“verticalmente”). Para a segunda dimensão, (“horizontalmente”), use espaços, como em[x y z]
. Para construir matrizes em blocos (concatenando nas duas primeiras dimensões), é usada a sintaxe[a b; c d]
para evitar confusão. - Dois-pontos
a:b
ea:b:c
constroem objetosRange
. Para construir um vetor completo, uselinspace
, ou “concatene” o intervalo colocando-o em colchetes,[a:b]
. - Funções retornam valores usando a palavra-chave
return
, ao invés de por citações a seus nomes na definição da função (veja A declaração “return” para mais detalhes). - Um arquivo pode conter um número qualquer de funções, e todas as definições vão ser visíveis de fora quando o arquivo for carregado.
- Reduções como
sum
,prod
, emax
são feitas sobre cada elemento de um array quando chamadas com um único argumento, como emsum(A)
. - Funções como
sort
que operam por padrão em colunas (sort(A)
é equivalente asort(A,1)
) não possuem comportamento especial para arrays 1xN; o argumento é retornado inalterado, já que a operação feita foisort(A,1)
. Para ordenar uma matriz 1xN como um vetor, usesort(A,2)
. - Parênteses devem ser usados para chamar uma função com zero
argumentos, como em``tic()`` and
toc()
. - Não use ponto-e-vírgula para encerrar declarações. Os resultados
de declarações não são automaticamente impressos (exceto no prompt
interativo), e linhas de código não precisam terminar com
ponto-e-vírgula. A função
println
pode ser usada para imprimir um valor seguido de uma nova linha. - Se
A
eB
são arrays,A == B
não retorna um array de booleanos. UseA .== B
no lugar. O mesmo vale para outros operaores booleanos,<
,>
,!=
, etc. - Os elementos de uma coleção podem ser passados como argumentos para
uma função usando
...
, como emxs=[1,2]; f(xs...)
. - A função
svd
de Julia retorna os valores singulares como um vetor, e não como uma matriz diagonal.
Diferenças notáveis em relação a R¶
Um dos objetivos de Julia é providenciar uma linguagem eficiente para análise de dados e programação estatística. Para usuários de Julia vindos de R, estas são algumas diferenças importantes:
Julia usa
=
para atribuição. Julia não provê nenhum outro operador alternativo, como<-
ou<-
.Julia constrói vetores usando colchetes. O
[1, 2, 3]
de Julia é o equivalente doc(1, 2, 3)
de R.As operações matriciais de Julia são mais parecidas com a notação matemática tradicional do que as de R. Se
A
eB
são matrizes, entãoA * B
define a multiplicação de matrizes em Julia equivalente àA %*% B
de R. Em R, essa notação faria um produto de Hadamard (elemento a elemento). Para obter a multiplicação elemento a elemento em Julia, você deve escreverA .* B
.Julia transpõe matrizes usando o operador
'
. OA'
em Julia é então equivalente aot(A)
de R.Julia não requer parênteses ao escrever condições
if
ou loopsfor
: usefor i in [1, 2, 3]
no lugar defor (i in c(1, 2, 3))
eif i == 1
no lugar deif (i == 1)
.Julia não trata os números
0
e1
como booleanos. Você não pode escreverif (1)
em Julia, porque condiçõesif` só aceitam booleanos. No lugar, escreva ``if true
.Julia não provê funções
nrow
encol
. Usesize(M, 1)
no lugar denrow(M)
esize(M, 2)
no lugar dencol(M)
.A SVD de Julia não é reduzida por padrão, diferentemente de R. Para obter resultados semelhantes aos de R, você deverá chamar
svd(X, true)
em uma matrixX
.Julia é uma linguagem muito cautelosa em distinguir escalares, vetores e matrizes. Em R,
1
ec(1)
são iguais. Em Julia, eles não podem ser usados um no lugar do outro. Uma consequência potencialmente confusa é quex' * y
para vetoresx
ey
é um vetor de um elemento, e não um escalar. Para obter um escalar, usedot(x, y)
.As funções
diag()
ediagm()
de Julia não são parecidas com as de R.Julia não pode atribuir os resultados de chamadas de funções no lado esquerdo de uma operação: você não pode escrever
diag(M) = ones(n)
Julia desencoraja popular o namespace principal com funções. A maior parte das funcionalidades estatísticas para Julia é encontrada em pacotes como o DataFrames e o Distributions.
- Funções de distribuições são encontradas no pacote Distributions
- O pacote DataFrames provê data frames.
- Fórmulas para GLM devem ser escapadas: use
:(y ~ x)
no lugar dey ~ x
.
Julia provê enuplas e tabelas de espalhamento reais, mas as listas de R. Quando precisar retornar múltiplos itens, você tipicamente deverá utilizar uma tupla: ao invés de
list(a = 1, b = 2)
, use(1, 2)
.Julia encoraja a todos usuários escreverem seus próprios tipos. Os tipos de Julia são bem mais fáceis de se usar do que os objetos S3 ou S4 de R. O sistema de multiple dispatch de Julia significa que
table(x::TypeA)
etable(x::TypeB)
agem comotable.TypeA(x)
etable.TypeB(x)
em R.Em Julia, valores são passados e atribuídos por referência. Se uma função modifica um array, as mudanças serão visíveis no lugar de chamada. Esse comportamento é bem diferente do de R, e permite que novas funções operem em grandes estruturas de dados de maneira muito mais eficiente.
Concatenação de vetores e matrizes é feita usando
hcat
evcat
, nãoc
,rbind
ecbind
.Um objeto
Range
a:b
em Julia não é uma forma abreviada de um vetor como em R, mas sim um tipo especializado de objeto que é utilizado para iteração sem muito gasto de memória. Para um converter umRange
em um vetor, você precisa cercá-lo por colchetes:[a:b]
.Julia tem várias funções que podem alterar seus argumentos. For exemplo, há tanto
sort(v)
quantosort!(v)
.Em R, eficiência requer vetorização. Em Julia, quase o contrário é verdadeiro: o código mais eficiente é frequentemente o desvetorizado.
Diferentemente de R, não há avaliação preguiçosa [2] [3] em Julia. Para a maioria dos usuários, isso significa que há poucas expressões ou nomes de coluna sem aspas.
Julia não possui tipo
NULL
.Não há equivalente do
assign
ouget
de R em Julia.
Notas de rodapé
[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 |