Julia Language
Tableaux

Syntaxe

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Tableau (type, dims ...)
• ceux (type, dims ...)
• zéros (type, dims ...)
• trues (type, dims ...)
• falses (type, dims ...)
• pousser! (A, x)
• pop! (A)
• décaler (A, x)
• déplacer! (A)

Paramètres

Construction manuelle d'un tableau simple

On peut initialiser manuellement un tableau Julia en utilisant la syntaxe entre crochets:

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

La première ligne après la commande indique la taille du tableau que vous avez créé. Il montre également le type de ses éléments et sa dimensionnalité (dans ce cas Int64 et 1 , respectivement). Pour un tableau à deux dimensions, vous pouvez utiliser des espaces et des points-virgules:

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

Pour créer un tableau non initialisé, vous pouvez utiliser la méthode Array(type, dims...) :

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

Les fonctions zeros , ones , trues , falses ont des méthodes qui se comportent exactement de la même façon, mais produisent des tableaux pleins de 0.0 , 1.0 , True ou False , respectivement.

Types de tableaux

Dans Julia, les tableaux ont des types paramétrés par deux variables: un type T et une dimensionalité D ( Array{T, D} ). Pour un tableau à 1 dimension d'entiers, le type est:

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

Si le tableau est une matrice à deux dimensions, D est égal à 2:

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

Le type d'élément peut également être des types abstraits:

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

Ici, Any (un type abstrait) est le type du tableau résultant.

Spécification des types lors de la création de tableaux

Lorsque nous créons un tableau de la manière décrite ci-dessus, Julia fera de son mieux pour en déduire le type approprié. Dans les exemples initiaux ci-dessus, nous avons entré des entrées qui ressemblaient à des entiers, et Julia a donc Int64 type Int64 par défaut. Parfois, cependant, nous pourrions vouloir être plus précis. Dans l'exemple suivant, nous spécifions que nous voulons que le type soit à la place Int8 :

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

Nous pourrions même spécifier le type comme Float64 , même si nous écrivons les entrées d'une manière qui pourrait être interprétée comme des entiers par défaut (par exemple, écrire 1 au lieu de 1.0 ). par exemple

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

Tableaux de tableaux - Propriétés et construction

Dans Julia, vous pouvez avoir un tableau contenant d'autres objets de type Array. Considérez les exemples suivants d'initialisation de différents types de tableaux:

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

Considérons par exemple les différences entre C et D ici:

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) produit un objet de type Array{Float64,1} . Comme la seule spécification pour les éléments de C est qu'ils sont des tableaux avec des éléments de type Float64, cela correspond à la définition de C Mais, pour D nous avons spécifié que les éléments doivent être des tableaux à deux dimensions. Donc, puisque rand(3) ne produit pas de tableau à deux dimensions, nous ne pouvons pas l’utiliser pour attribuer une valeur à un élément spécifique de D

Spécifier des dimensions spécifiques de tableaux dans un tableau

Bien que nous puissions spécifier qu'un tableau contiendra des éléments de type Array, et que nous pouvons spécifier que, par exemple, ces éléments doivent être des tableaux à deux dimensions, nous ne pouvons pas spécifier directement les dimensions de ces éléments. Par exemple, nous ne pouvons pas spécifier directement que nous voulons un tableau contenant 10 tableaux, chacun représentant 5,5. Nous pouvons voir cela à partir de la syntaxe de la fonction Array() utilisée pour construire un tableau:

Tableau {T} (dims)

construit un tableau dense non initialisé avec le type d'élément T. dims peut être un tuple ou une série d'arguments entiers. La syntaxe Array (T, dims) est également disponible, mais obsolète.

Le type d'un tableau dans Julia englobe le nombre de dimensions, mais pas la taille de ces dimensions. Ainsi, il n’ya pas de place dans cette syntaxe pour spécifier les dimensions précises. Néanmoins, un effet similaire pourrait être obtenu en utilisant une compréhension Array:

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

Remarque: cette documentation reflète la réponse SO suivante

Initialiser un tableau vide

Nous pouvons utiliser le [] pour créer un tableau vide dans Julia. L'exemple le plus simple serait:

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

Les tableaux de type Any ne fonctionneront généralement pas aussi bien que ceux avec un type spécifié. Ainsi, par exemple, nous pouvons utiliser:

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}

Voir Initialiser un tableau vide de tuples dans Julia pour la source du dernier exemple.

Vecteurs

Les vecteurs sont des tableaux à une dimension et supportent principalement la même interface que leurs homologues multidimensionnels. Cependant, les vecteurs prennent également en charge des opérations supplémentaires.

Tout d'abord, notez que Vector{T} où T est un type signifie la même chose que Array{T,1} .

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

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

On lit Array{Int64,1} comme "tableau unidimensionnel d' Int64 ".

Contrairement aux tableaux multidimensionnels, les vecteurs peuvent être redimensionnés. Des éléments peuvent être ajoutés ou supprimés à l'avant ou à l'arrière du vecteur. Ces opérations sont toutes des durées d'amortissement constantes .

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

Comme c'est la convention, chacune de ces fonctions push! , pop! , unshift! et shift! se termine par un point d'exclamation pour indiquer qu'ils modifient leur argument. Les fonctions push! et unshift! retourne le tableau, alors que pop! et shift! renvoyer l'élément supprimé

Enchaînement

Il est souvent utile de construire des matrices à partir de matrices plus petites.

Concaténation horizontale

Les matrices (et les vecteurs, qui sont traités comme des vecteurs de colonne) peuvent être concaténés horizontalement à l'aide de la fonction 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

Il existe une syntaxe pratique, en utilisant la notation entre crochets et les espaces:

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

Cette notation peut correspondre étroitement à la notation des matrices de blocs utilisées en algèbre linéaire:

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

Notez que vous ne pouvez pas concaténer horizontalement une seule matrice à l'aide de la syntaxe [] , car cela créerait plutôt un vecteur à un élément de matrices:

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

Concaténation verticale

La concaténation verticale est comme une concaténation horizontale, mais verticale. La fonction de concaténation verticale est 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

Alternativement, la notation entre crochets peut être utilisée avec des points-virgules ; comme délimiteur:

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

Les vecteurs peuvent également être concaténés verticalement; le résultat est un vecteur:

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 concaténation horizontale et verticale peut être combinée:

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