Tableaux Julia

Un tableau est une collection d'éléments du même type de données disposés dans un certain ordre ; il peut s'agir d'un tableau unidimensionnel ou d'un tableau multidimensionnel.

Julia prend en charge les structures de données de type tableau, qui peuvent stocker une collection ordonnée dont la taille n'est pas fixe et dont les éléments peuvent être du même type ou de types différents.

Les tableaux Julia sont des collections typées mutables utilisées pour les listes, les vecteurs, les tables et les matrices.

Les clés d'index des tableaux Julia peuvent être représentées par des entiers, et la taille d'un tableau n'est pas fixe.

Julia fournit de nombreuses fonctions pour nous aider à manipuler les tableaux, comme ajouter des éléments aux tableaux, fusionner des tableaux, etc.

Les tableaux Julia utilisent des crochets[...]pour les spécifier, et plusieurs éléments utilisent des virgules,pour les séparer.

La syntaxe de création d'un tableau unidimensionnel (c'est-à-dire un vecteur) est :

[A, B, C, ...]

Création de tableaux unidimensionnels

L'exemple suivant crée un tableau unidimensionnel simple :

Exemple

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

Dans l’exemple ci-dessus, nous avons créé un tableau à une dimension contenant 3 éléments, chaque élément est un entier 64 bits, et ce tableau à une dimension est lié à la variablearr.

Les types des éléments d’un tableau peuvent aussi être différents :

Exemple

julia> arr =[1, "EXAMPLE", 2.5, pi]
4-element Vector{Any}:
1
"EXAMPLE"
2.5
π = 3.1415926535897...

Dans l’exemple ci-dessus, nous avons créé un tableau à une dimension contenant 4 éléments de types différents.piest une constanteπ, chaque élément est un entier 64 bits, et ce tableau à une dimension est lié à la variablearr.

Bien sûr, vous pouvez aussi forcer le type :

Exemple

julia> arr = Int64[1,2,3]
3-element Vector{Int64}:
1
2
3
julia> arr2 = String["Taobao","EXAMPLE","GOOGLE"]
3-element Vector{String}:
"Taobao"
"EXAMPLE"
"GOOGLE"

Le tableau dans l'exemple ci-dessusarrest limité aux entiers,arr2est limité aux chaînes de caractères.

Nous pouvons également créer un tableau vide :

Exemple

julia> arr = Int64[]
Int64[]

julia> arr2 = String[]
String[]

Le tableau créé est directement accessible à l'aide de valeurs d'indice. La première valeur a l'indice 1 (pas 0), la deuxième a l'indice 2, et ainsi de suite. La dernière peut utiliserendpour la représenter :

Exemple

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

julia> arr[2]
2
julia> arr2 = String["Taobao","EXAMPLE","GOOGLE"]
3-element Vector{String}:
"Taobao"
"EXAMPLE"
"GOOGLE"

julia> arr2[1]
"Taobao"

julia> arr2[end]
"GOOGLE"

Spécification des types et dimensions de tableau

Nous pouvons également utiliser la syntaxe suivante pour spécifier le type et les dimensions d'un tableau :

Array{type}(undef, dims...)

undefindique que le tableau n'est pas initialisé.

dims...peut être un tuple de dimensions unique ou multiple, ou un ensemble de valeurs lorsque les dimensions sont passées comme arguments variables.

dims...Le nombre représente le nombre d'éléments ; plusieurs dimensions utilisent des virgules,pour les séparer.

Exemple

julia> array = Array{Int64}(undef, 3) # représente un tableau à une dimension avec 3 éléments
3-element Vector{Int64}:
4834342704
4377305096
0

julia> array = Array{Int64}(undef, 3, 3, 3) # représente un tableau à 3 dimensions, avec 3 éléments dans chaque dimension
3×3×3 Array{Int64, 3}:
[:, :, 1] =
4562265712 0 0
1 0 0
0 0 0

[:, :, 2] =
0 0 0
0 0 0
0 0 0

[:, :, 3] =
0 0 0
0 0 0
0 0 0

Dans l'exemple ci-dessus, nous plaçons le type du tableau entre accolades{}, undef est utilisé pour définir le tableau comme non initialisé à une valeur connue ; c'est pourquoi nous obtenons des nombres aléatoires dans la sortie.

Création de tableaux et de matrices à deux dimensions

Nous pouvons omettre les virgules entre les éléments du tableau,ou utiliser deux signes deux-points;;, de cette façon nous pouvons créer un tableau à deux dimensions, comme dans l'exemple suivant :

Exemple

julia> [1 2 3 4]
1×4 Matrix{Int64}:
1 2 3 4
julia> [1;; 2;; 3;; 4]
1×4 Matrix{Int64}:
1 2 3 4

Remarque :La sortie de la première ligne1×4 Matrix{Int64}:, 1x4 représente une matrice avec une ligne et quatre colonnes.

Bien qu'il n'ait qu'une seule ligne, il s'agit toujours d'un tableau à deux dimensions, car Julia ne reconnaît que les vecteurs colonnes, et non ce qu'on appelle des vecteurs lignes.

Pour ajouter une autre ligne, ajoutez simplement un point-virgule;, voir l'exemple suivant :

Exemple

julia> [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4

Vous pouvez également utiliser des deux-points:et des espaces pour y parvenir, voir l'exemple suivant :

Exemple

julia> [1:2 3:4]
2×2 Matrix{Int64}:
1 3
2 4

Remarque :La sortie dans la première ligne2×2 Matrix{Int64}:, 2×2 représente une matrice avec deux lignes et deux colonnes.

Nous pouvons également intégrer des tableaux à une dimension de même longueur entre crochets[]et les séparer par des espaces pour créer un tableau à deux dimensions :

Exemple

julia> [[1,2] [3,4] [5,6]]
2×3 Matrix{Int64}:
1 3 5
2 4 6

2x3représente un tableau à deux lignes et trois colonnes.

Ci-dessous, nous utilisons de manière flexible des points-virgules;et des espaces pour créer un tableau à deux dimensions avec deux lignes et trois colonnes, et un avec trois lignes et deux colonnes :

Exemple

julia> [[1;2] [3;4] [5;6]]
2×3 Matrix{Int64}:
1 3 5
2 4 6

julia> [[1 2]; [3 4]; [5 6]]
3×2 Matrix{Int64}:
1 2
3 4
5 6

Utilisation des fonctions de plage pour créer des tableaux

Points de suspension ...

Vous pouvez utiliser les points de suspension...pour créer un tableau, comme dans l'exemple suivant :

Exemple

julia> [0:10...]
11-element Vector{Int64}:
0
1
2
3
4
5
6
7
8
9
10

Fonction collect()

La syntaxe de la fonction collect() est la suivante :

collect(start:step:stop)

start est la valeur de départ, step est le pas, et stop est la valeur finale.

Cette fonction retourne un tableau.

Dans l'exemple suivant, la valeur est 1, le pas est 2, et la valeur de fin est 13 :

Exemple

julia> collect(1:2:13)
7-element Vector{Int64}:
1
3
5
7
9
11
13

La fonction collect() peut également spécifier un type, avec la syntaxe suivante :

collect(element_type, start:step:stop)

L'exemple suivant crée un tableau de nombres à virgule flottante :

Exemple

julia> collect(Float64, 1:2:5)
3-élément Vector{Float64}:
1.0
3.0
5.0

Fonction range()

La fonction range() peut générer un intervalle et spécifier un pas, ce qui est pratique pour que la fonction collect() puisse l'appeler.

La syntaxe de la fonction range() est la suivante :

range(start, stop, length) range(start, stop; length, step) range(start; length, stop, step) range(;start, length, stop, step)

start est la valeur de départ, step est le pas, stop est la valeur de fin, et length est la longueur.

Exemple

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

Si length n'est pas spécifié, etstop - startn'est pas un multiple entier de step, alors une plage qui se termine avant stop sera générée.

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

Création de tableaux avec range() et collect() :

Exemple

julia> collect(range(1,stop=10))
10-element Vector{Int64}:
1
2
3
4
5
6
7
8
9
10
julia> collect(range(1, length=15, stop=150))
15-élément Vector{Float64}:
1.0
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
75.5
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0

Création de tableaux avec les compréhensions et les générateurs

Une autre façon utile de créer des tableaux consiste à utiliser des compréhensions.

La syntaxe des compréhensions de tableaux est la suivante :

A = [ F(x,y,...) for x=rx, y=ry, ... ]

F(x,y,...) est évalué pour chaque valeur des variables x, y, etc. dans les listes données. Les valeurs peuvent être spécifiées sous forme de tout objet itérable, mais il s'agit généralement de plages comme 1:n ou 2:(n-1), ou de valeurs de tableau explicites comme [1.2, 3.4, 5.7]. Le résultat est un tableau dense à N dimensions dont les dimensions sont obtenues en concaténant les dimensions des plages de variables rx, ry, etc., et chaque évaluation de F(x,y,...) renvoie un scalaire.

Exemple

julia> [n^2 for n in 1:10]
10-element Vector{Int64}:
1
4
9
16
25
36
49
64
81
100

Création d'un tableau à deux dimensions :

Exemple

julia> [n*m for n in 1:10, m in 1:10]
10×10 Matrix{Int64}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100

Les compréhensions peuvent également être écrites sans crochets, produisant un objet appelé générateur.

L'exemple suivant crée un tableau :

Exemple

julia> collect(n^2 for n in 1:5)
5-element Vector{Int64}:
1
4
9
16
25

L'expression suivante calcule la somme d'une séquence sans allouer de mémoire :

Exemple

julia> sum(1/n^2 for n=1:1000)
1.6439345666815615

Fonctions de base des tableaux Julia

Fonction	Description
`eltype(A)`	`A`le type des éléments dans
`length(A)`	`A`le nombre d'éléments dans
`ndims(A)`	`A`la dimension de
`size(A)`	un tuple contenant`A`un tuple avec le nombre d'éléments dans chaque dimension
`size(A,n)`	`A`Non.`n`le nombre d'éléments dans la dimension
`axes(A)`	un tuple contenant`A`un tuple d'indices valides
`axes(A,n)`	Non.`n`la plage d'indices valides pour la dimension
`eachindex(A)`	un itérateur efficace pour accéder à`A`chaque position dans
`stride(A,k)`	sur le`k`pas sur la dimension (distance en indice linéaire entre éléments adjacents)
`strides(A)`	un tuple contenant le pas sur chaque dimension

Construction et initialisation en Julia

Julia fournit de nombreuses fonctions pour construire et initialiser des tableaux. Dans les fonctions suivantes, l'argument dims ... peut être un tuple pour représenter les dimensions, ou un nombre variable de valeurs entières comme dimensions. Le premier argument de la plupart des fonctions représente le type d'élément T du tableau. Si le type T est omis, il vaut par défaut Float64.

Fonction	Description
`Array{T}(undef, dims...)`	Un tableau dense non initialisé`Array`
`zeros(T, dims...)`	Un tableau de zéros`Array`
`ones(T, dims...)`	Un tableau dont tous les éléments sont égaux à 1`Array`
`trues(dims...)`	Un tableau dont chaque élément est`true`de`BitArray`
`falses(dims...)`	Un tableau dont chaque élément est`false`de`BitArray`
`reshape(A, dims...)`	Un tableau contenant les mêmes`A`tableau avec les mêmes données mais des dimensions différentes
`copy(A)`	copy`A`
`deepcopy(A)`	copie profonde, c'est-à-dire copier`A`, et en copiant récursivement ses éléments
`similar(A, T, dims...)`	Un tableau avec les mêmes`A`un tableau non initialisé ayant le même type (il s'agit ici de dense, sparse, etc.) mais avec le type d'élément et les dimensions spécifiés. Les deuxième et troisième paramètres sont tous deux facultatifs ; s'ils sont omis, ils prennent par défaut le type d'élément et`A`les dimensions de.
`reinterpret(T, A)`	et`A`Un tableau ayant les mêmes données binaires, mais le type d'élément est`T`
`rand(T, dims...)`	Un tableau aléatoire`Array`, les valeurs des éléments sont $[0, 1)$ distribuées uniformément dans l'intervalle semi-ouvert et suivant une loi indépendante et identique du premier ordre^[1]
`randn(T, dims...)`	Un tableau aléatoire`Array`, les éléments suivent une loi normale standard, indépendants et identiquement distribués
`Matrix{T}(I, m, n)`	`m`line`n`matrice identité avec des colonnes (il faut d'abord exécuter`using LinearAlgebra`afin d'utiliser`I`）
`range(start, stop=stop, length=n)`	from`start`à`stop`with`n`plage d'éléments espacés linéairement
`fill!(A, x)`	Avec la valeur`x`remplir le tableau`A`
`fill(x, dims...)`	Un tableau rempli de`x`rempli`Array`

zeros()Créer une instance de tableau, les valeurs initiales des éléments sont toutes à 0 :

Exemple

julia> zeros(Int8, 2, 3)
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros(Int8, (2, 3))
2×3 Matrix{Int8}:
0 0 0
0 0 0

julia> zeros((2, 3))
2×3 Matrix{Float64}:
0.0 0.0 0.0
0.0 0.0 0.0

Autres extensions