Julia Language
Array

Sintassi

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Array (type, dims ...)
• quelli (tipo, dim. ...)
• zeri (tipo, dim. ...)
• trues (type, dims ...)
• falsi (tipo, oscuramento ...)
• spingere! (A, x)
• pop! (A)
• unshift! (A, x)
• spostare! (A)

Parametri

Costruzione manuale di un array semplice

Si può inizializzare manualmente una matrice di Julia usando la sintassi delle parentesi quadre:

julia> x = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

La prima riga dopo il comando mostra la dimensione dell'array che hai creato. Mostra anche il tipo dei suoi elementi e la sua dimensionalità (int questo caso Int64 e 1 , in modo ripetitivo). Per un array bidimensionale, puoi usare spazi e punto e virgola:

julia> x = [1 2 3; 4 5 6]
2x3 Array{Int64,2}:
 1  2  3
 4  5  6

Per creare un array non inizializzato, puoi utilizzare il metodo Array(type, dims...) :

julia> Array(Int64, 3, 3)
3x3 Array{Int64,2}:
 0  0  0
 0  0  0
 0  0  0

Le funzioni zeros , ones , trues , falses hanno metodi che si comportano esattamente allo stesso modo, ma producono matrici piene di 0.0 , 1.0 , True o False , rispettivamente.

Tipi di matrice

In Julia, gli array hanno tipi parametrizzati da due variabili: un tipo T e una dimensionalità D ( Array{T, D} ). Per un array 1-dimensionale di numeri interi, il tipo è:

julia> x = [1, 2, 3];
julia> typeof(x)
Array{Int64, 1}

Se l'array è una matrice bidimensionale, D uguale a 2:

julia> x = [1 2 3; 4 5 6; 7 8 9]
julia> typeof(x)
Array{Int64, 2}

Il tipo di elemento può anche essere tipi astratti:

julia> x = [1 2 3; 4 5 "6"; 7 8 9]
3x3 Array{Any,2}:
 1  2  3   
 4  5 "6"
 7  8  9

Qui Any (un tipo astratto) è il tipo dell'array risultante.

Specifica dei tipi durante la creazione di matrici

Quando creiamo una matrice nel modo descritto sopra, Julia farà del suo meglio per dedurre il tipo corretto che potremmo volere. Negli esempi iniziali di cui sopra, abbiamo inserito input che sembravano numeri interi, e quindi Julia si è impostato di default sul tipo di Int64 predefinito. A volte, tuttavia, potremmo voler essere più specifici. Nell'esempio seguente, specifichiamo che vogliamo che il tipo sia invece Int8 :

x1 = Int8[1 2 3; 4 5 6; 7 8 9]
typeof(x1)  ## Array{Int8,2}

Potremmo anche specificare il tipo come qualcosa come Float64 , anche se scriviamo gli input in un modo che potrebbe altrimenti essere interpretato come numeri interi per impostazione predefinita (ad esempio scrivendo 1 anziché 1.0 ). per esempio

x2 = Float64[1 2 3; 4 5 6; 7 8 9]

Array di array - Proprietà e costruzione

In Julia, puoi avere una matrice che contiene altri oggetti di tipo Array. Considera i seguenti esempi di inizializzazione di vari tipi di array:

A = Array{Float64}(10,10)  # A single Array, dimensions 10 by 10, of Float64 type objects

B = Array{Array}(10,10,10)  # A 10 by 10 by 10 Array.  Each element is an Array of unspecified type and dimension.

C = Array{Array{Float64}}(10)  ## A length 10, one-dimensional Array.  Each element is an Array of Float64 type objects but unspecified dimensions

D = Array{Array{Float64, 2}}(10)  ## A length 10, one-dimensional Array.  Each element of is an 2 dimensional array of Float 64 objects

Si consideri ad esempio, le differenze tra C e D qui:

julia> C[1] = rand(3)
3-element Array{Float64,1}:
 0.604771
 0.985604
 0.166444

julia> D[1] = rand(3)
ERROR: MethodError: 

rand(3) produce un oggetto di tipo Array{Float64,1} . Poiché l'unica specifica per gli elementi di C è che siano matrici con elementi di tipo Float64, ciò rientra nella definizione di C Ma, per D abbiamo specificato che gli elementi devono essere matrici bidimensionali. Quindi, dato che rand(3) non produce un array bidimensionale, non possiamo usarlo per assegnare un valore a un elemento specifico di D

Specificare le dimensioni specifiche delle matrici all'interno di una matrice

Sebbene possiamo specificare che una matrice conserverà elementi che sono di tipo Array, e possiamo specificare che, per esempio quegli elementi dovrebbero essere matrici bidimensionali, non possiamo specificare direttamente le dimensioni di quegli elementi. Ad esempio non possiamo specificare direttamente che vogliamo una matrice che contiene 10 matrici, ognuna delle quali è 5,5. Possiamo vedere questo dalla sintassi per la funzione Array() utilizzata per costruire una matrice:

Array {T} (dim)

costruisce una matrice densa non inizializzata con il tipo di elemento T. dims può essere una tupla o una serie di argomenti interi. Anche la matrice di sintassi (T, dims) è disponibile, ma deprecata.

Il tipo di una matrice in Julia racchiude il numero delle dimensioni ma non le dimensioni di quelle dimensioni. Pertanto, non c'è spazio in questa sintassi per specificare le dimensioni precise. Tuttavia, un effetto simile potrebbe essere ottenuto usando una comprensione di matrice:

E = [Array{Float64}(5,5) for idx in 1:10]

Nota: questa documentazione rispecchia la seguente risposta SO

Inizializza una matrice vuota

Possiamo usare [] per creare una matrice vuota in Julia. L'esempio più semplice sarebbe:

A = [] # 0-element Array{Any,1}

Le matrici di tipo Any generalmente non funzionano come quelle con un tipo specificato. Quindi, ad esempio, possiamo usare:

B = Float64[]  ## 0-element Array{Float64,1}
C = Array{Float64}[]  ## 0-element Array{Array{Float64,N},1}
D = Tuple{Int, Int}[] ## 0-element Array{Tuple{Int64,Int64},1}

Vedi Inizializza una matrice vuota di tuple in Julia come fonte dell'ultimo esempio.

Vettori

I vettori sono matrici unidimensionali e supportano principalmente la stessa interfaccia delle loro controparti multidimensionali. Tuttavia, i vettori supportano anche operazioni aggiuntive.

Prima di tutto, nota che Vector{T} dove T è un tipo indica lo stesso di Array{T,1} .

julia> Vector{Int}
Array{Int64,1}

julia> Vector{Float64}
Array{Float64,1}

Si legge l' Array{Int64,1} come "matrice unidimensionale di Int64 ".

A differenza degli array multidimensionali, i vettori possono essere ridimensionati. Gli elementi possono essere aggiunti o rimossi dalla parte anteriore o posteriore del vettore. Queste operazioni sono tutti tempi di ammortamento costanti .

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> push!(A, 4)
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> A
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> pop!(A)
4

julia> A
3-element Array{Int64,1}:
 1
 2
 3

julia> unshift!(A, 0)
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> A
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> shift!(A)
0

julia> A
3-element Array{Int64,1}:
 1
 2
 3

Come è convenzione, ognuna di queste funzioni push! pop! , unshift! e shift! termina con un punto esclamativo per indicare che stanno mutando il loro argomento. Le funzioni push! e unshift! restituisce l'array, mentre pop! e shift! restituire l'elemento rimosso.

Concatenazione

Spesso è utile costruire matrici con matrici più piccole.

Concatenazione orizzontale

Le matrici (e i vettori, che sono trattati come vettori di colonne) possono essere concatenati orizzontalmente usando la funzione hcat .

julia> hcat([1 2; 3 4], [5 6 7; 8 9 10], [11, 12])
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

È disponibile la sintassi della comodità, utilizzando la notazione e gli spazi tra parentesi quadre:

julia> [[1 2; 3 4] [5 6 7; 8 9 10] [11, 12]]
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

Questa notazione può corrispondere strettamente alla notazione per le matrici di blocchi utilizzate nell'algebra lineare:

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6; 7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> [A B]
2×4 Array{Int64,2}:
 1  2  5  6
 3  4  7  8

Si noti che non è possibile concatenare orizzontalmente una singola matrice usando la sintassi [] , poiché ciò creerebbe invece un vettore a un elemento di matrici:

julia> [A]
1-element Array{Array{Int64,2},1}:
 [1 2; 3 4]

Concatenazione verticale

La concatenazione verticale è come la concatenazione orizzontale, ma nella direzione verticale. La funzione per la concatenazione verticale è vcat .

julia> vcat([1 2; 3 4], [5 6; 7 8; 9 10], [11 12])
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

In alternativa, la notazione della parentesi quadra può essere utilizzata con il punto e virgola ; come delimitatore:

julia> [[1 2; 3 4]; [5 6; 7 8; 9 10]; [11 12]]
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

Anche i vettori possono essere concatenati verticalmente; il risultato è un vettore:

julia> A = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

julia> B = [4, 5]
2-element Array{Int64,1}:
 4
 5

julia> [A; B]
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

La concatenazione orizzontale e verticale può essere combinata:

julia> A = [1 2
            3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6 7]
1×3 Array{Int64,2}:
 5  6  7

julia> C = [8, 9]
2-element Array{Int64,1}:
 8
 9

julia> [A C; B]
3×3 Array{Int64,2}:
 1  2  8
 3  4  9
 5  6  7