Os Encantamentos da Elyse

Um objetivo central do Julia é conseguir efetuar cálculos sobre dados numéricos, de forma rápida e eficiente. Muitos dados numéricos.

Normalmente, os dados são guardados em arrays (ou nalgum tipo relacionado), por isso é razoável dizer que os arrays estão no centro da linguagem Julia.

Os arrays podem ter tamanho arbitrário (sujeitos apenas às limitações de memória do teu hardware) e podem ter um número arbitrário de dimensões.

Este Conceito introdutório concentra-se no básico dos arrays unidimensionais, que se chamam vetores.

Criar vetores

Em Julia, um vetor é uma sequência ordenada de valores que podem ser acedidos por um número de índice.

A forma mais simples de criar um vetor é listar os valores entre parênteses retos:

julia> num_vec = [1, 4, 9]
3-element Vector{Int64}:
 1
 4
 9

julia> str_vec = ["arrays", "are", "important"]
3-element Vector{String}:
 "arrays"
 "are"
 "important"

O tipo Vector corresponde ao tipo de cada elemento.

Então os vetores têm de ser homogéneos (todos os elementos do mesmo tipo)?

A certo nível, sim, e recomenda-se que procures isso se quiseres o melhor desempenho. Contudo, o Julia pode contornar esta limitação (quando necessário) usando o tipo Any:

julia> mixed_vector = [1, "str", 'c']
3-element Vector{Any}:
 1
  "str"
  'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

Quando crias um vetor vazio, o Julia usa por omissão o tipo de elemento Any, mas este pode ser definido de forma mais específica anotando o array vazio com o tipo de elemento pretendido.

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

Por favor, lê e lembra-te desta regra:

• Por omissão, a indexação em Julia começa em 1, não em 0.

Isto é familiar para quem já usou outras linguagens de ciência de dados (R, Matlab, Fortran...), mas pode parecer surpreendente para cientistas de computação com experiência em linguagens do tipo C.

De resto, os índices funcionam como imaginas: basta colocá-los entre parênteses retos:

squares = [0, 1, 4, 9, 16]
squares[1]  # 0
squares[3]  # 4
squares[begin]  # 0 ("begin" is synonym for 1)
squares[end]  # 16 ("end" is synonym for length(squares))

Repara na conveniência de indexar com end (que é muito útil) e begin (que provavelmente não é).

Os programadores de Python podem estar a perguntar-se sobre índices negativos. Não penses nisso: não fazem parte do Julia e vão lançar um BoundsError, tal como qualquer índice inferior a 1 ou superior a length(squares).

Operações com vetores

Os vetores em Julia são mutáveis: podemos alterar o conteúdo de células individuais.

julia> vals = [1, 3, 5, 7]
4-element Vector{Int64}:
 1
 3
 5
 7

julia> vals[2] = 4  # reassign the value of this element
4

# Only the value at position 2 changes:
julia> vals
4-element Vector{Int64}:
 1
 4
 5
 7

Há muitas funções disponíveis para manipular vetores, embora a documentação do Julia as generalize para "coleções" em vez de vetores.

Repara que, por convenção, as funções que alteram os seus argumentos têm ! no nome. O compilador não vai impor isto, mas é uma convenção muito forte no mundo Julia.

Estas são algumas das funções úteis:

• Para adicionar valores ao fim do vetor, usa push!().
• Para remover o último valor, usa pop!().
• Para operar sobre o início do vetor, as funções correspondentes são pushfirst!() e popfirst!().
• Para inserir ou remover um elemento em qualquer posição, existem insert!() e deleteat!().

julia> vals = [1, 3]
2-element Vector{Int64}:
 1
 3

julia> push!(vals, 5, 6)  # can add multiple values
4-element Vector{Int64}:
 1
 3
 5
 6

julia> pop!(vals)  # mutates vals, return popped value
6

julia> vals
3-element Vector{Int64}:
 1
 3
 5