Os encantamentos de Elyse

Um dos objetivos centrais do Julia é conseguir fazer cálculos com dados numéricos de forma rápida e eficiente. Muitos dados numéricos.

Normalmente, esses dados ficam armazenados em arrays (ou em algum tipo relacionado), então é razoável dizer que os arrays são o coração da linguagem Julia.

Os arrays podem ter tamanho arbitrário (sujeitos apenas às limitações de memória do seu hardware) e podem ter quantas dimensões você quiser.

Este Conceito introdutório foca no básico dos arrays unidimensionais, que são chamados de Vectors.

Criando Vectors

No Julia, um Vector é uma sequência ordenada de valores que podem ser acessados por número de índice.

A forma mais simples de criar um Vector é listar os valores entre colchetes:

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 Vectors precisam ser homogêneos (todos os elementos do mesmo tipo)?

De certa forma, sim, e é recomendável buscar isso se você quiser o melhor desempenho. No entanto, o Julia consegue contornar essa 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)

Ao criar um Vector vazio, o Julia assume o tipo de elemento Any por padrão, mas isso pode ser definido de forma mais específica anotando o array vazio com o tipo de elemento desejado.

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

Por favor, leia e memorize esta regra:

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

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

Fora isso, os índices funcionam como você imagina: basta colocá-los entre colchetes:

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))

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

Quem programa em Python pode estar se perguntando sobre índices negativos. Não se preocupe: eles não fazem parte do Julia e vão gerar um BoundsError, assim como qualquer índice menor que 1 ou maior que length(squares).

Operações com Vector

Os Vectors no Julia são mutáveis: podemos alterar o conteúdo de posições 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

Existem muitas funções disponíveis para manipular Vectors, embora a documentação do Julia generalize isso para "coleções" em vez de Vectors.

Repare que, por convenção, funções que modificam sua entrada têm ! no nome. O compilador não vai obrigar isso, mas é uma convenção muito forte no mundo do Julia.

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

• Para adicionar valores ao fim do Vector, use push!().
• Para remover o último valor, use pop!().
• Para operar no início do Vector, 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