La définition de tableaux i.e. vecteurs, matrices, hypermatrices est un élément essentiel du Julia.
Julia ne possède qu'un seul type de tableau : Array on peut définir sont nombre d'entrées (1 entrée= 1 dimension ...) et sont contenu de façon assez générale (Un tableau peut contenir des matrices à chaque élément...
Une particularité est que les indices de tableaux commencent à 1, et l'accès aux éléments se fera à l'aide de '[' ’]' et non '(' ')' qui est réservé aux fonctions.
Avant de rentrer dans la construction et manipulation de tableau regardons une autre classe
Julia possède un Type particulier fait à l'aide du ":"
In [1]:
a=1:5
Out[1]:
In [2]:
a.+1
Out[2]:
In [3]:
typeof(a)
Out[3]:
In [4]:
b=0:0.5:2
Out[4]:
In [5]:
typeof(b)
Out[5]:
Ce type "formel" permet d'avoir une définition et une méthode associée sans stocker l'ensemble des valeurs. Attention celui-ci peut être vide :
In [6]:
d=1:0 # itérateur formel mais correspond à un ensemble vide de valeurs
Out[6]:
In [7]:
d=collect(d)
Out[7]:
In [8]:
a=1:5
aa=collect(a)
Out[8]:
In [9]:
collect(a')
Out[9]:
In [10]:
typeof(aa)
Out[10]:
La réponse est de la forme Array{Type,dim} un tableau de Type à dim entrées (1 pour vecteur, 2 pour matrices ...)
A remarquer :
In [11]:
aa[1]
Out[11]:
In [12]:
aa[end] # pour accèder au dernier élément
Out[12]:
In [13]:
aa[end-2:end].=1; println(aa)
Les crochets permettent la construction explicite de tableaux (ou leur concaténation)
In [14]:
A=[1 2 ; 3 4] # {espace} = séparateur de colonne
Out[14]:
In [15]:
AA=[A A] # concaténation par bloc
Out[15]:
In [16]:
hcat(A,A) # commande équivalent à la précédente [A A]
Out[16]:
In [17]:
AA=[A ; A]
Out[17]:
In [18]:
vcat(A,A) # commande équivalent à la précédente [A ; A]
Out[18]:
On peut accéder à tout ou partie d'un tableau à l'aide de 2 indices
In [19]:
A[2,1]
Out[19]:
In [20]:
A[2,:]
Out[20]:
In [21]:
A[:,2]
Out[21]:
In [22]:
A[end,end]
Out[22]:
In [23]:
B=[1 2 3 4]
Out[23]:
In [24]:
B=[1;2;3;4]
Out[24]:
A noter que l'on peut faire des tableaux de tout type voir de les mélanger (Any)
In [25]:
a=["un";"deux"]
Out[25]:
In [26]:
b=[1>2,true,false]
Out[26]:
In [27]:
c=["un"; 2 ; true]
Out[27]:
Le crochet [ ] permet également la construction rapide de matrice ou tableau comme le montre l'exemple si dessous pour construire une matrice de VanderMonde
$$ V_{i,j}=x_i^{j-1}$$
In [28]:
x=0:0.2:1;
V=[ x[i]^(j-1) for i=1:6, j=1:6] # ligne et colonne
Out[28]:
In [29]:
D=[ u*v for u=1:0.5:3, v=1:0.5:4]
Out[29]:
In [30]:
a=[]
push!(a,1) # => [1]
push!(a,2) # => [1,2]
push!(a,4) # => [1,2,4]
push!(a,6) # => [1,2,4,6]
Out[30]:
In [31]:
append!(a,a)
Out[31]:
A noté le Array{Any,1} !
In [32]:
a=zeros(Int32,1)
push!(a,1) # => [1]
push!(a,2) # => [1,2]
push!(a,4) # => [1,2,4]
push!(a,6)
Out[32]:
In [33]:
a=zeros(0)
Out[33]:
In [34]:
a=zeros(Int32,1)
Out[34]:
In [35]:
a=collect(1:5)
Out[35]:
In [36]:
a=fill(0.,3,2)
Out[36]:
In [37]:
a[2]=sqrt(2)
Out[37]:
In [38]:
a=map(Float64,a)
Out[38]:
In [39]:
a=Float64.(a)
Out[39]:
In [40]:
using LinearAlgebra
In [41]:
A=[1 2 ; 3 4]
size(A)
Out[41]:
In [42]:
det(A)
Out[42]:
In [43]:
tr(A)
Out[43]:
In [44]:
eigvals(A)
Out[44]:
In [45]:
A=[1 2;3 4];b=[2 ; 3]; #résolution du système Ax=b
x=A\b
Out[45]:
L'usage des fonction scientifiques se fait termes à termes pour l'ensemble des valeurs du tableau (sauf pour les fonctions matricielles comme exp, log ...). L'usage des opérations +,-,*</code>,^,/ et \(résolution) est disponible à condition de respecter les contraintes de dimension (multiplication matricielle par exemple). Sont ajouté des opérations termes à termes .\*,.^,./ et .\ toujours avec une contrainte de dimensions compatibles.
In [46]:
A=[1 2;3 4]
exp(A)
Out[46]:
In [47]:
exp.(A) # exponentielle matricielle
Out[47]:
De plus les tableaux possèdes des opérations de multiplication, division, puissance termes à termes
In [48]:
A^2 #Multiplication Matricielle
Out[48]:
In [49]:
A.^2 #Multiplication terme à terme
Out[49]:
In [50]:
A./[2 3 ; 4 5] #Division terme à terme
Out[50]:
In [51]:
A./2
Out[51]:
In [52]:
collect(1:5)>2
In [53]:
collect(1:5).>2
Out[53]:
In [54]:
collect(1:5).>[0;2;3;4;5]
Out[54]:
In [55]:
collect(1:5).>[0 2 3 4 5]
Out[55]:
In [56]:
max(2,3)
Out[56]:
In [57]:
max(1,2,3)
Out[57]:
In [58]:
max(1:5)
In [59]:
maximum(1:5)
Out[59]:
In [60]:
max.(1:5,2:6)
Out[60]:
In [61]:
a=fill(0.,2,3)
Out[61]:
In [62]:
a=fill(2,2)
Out[62]:
In [63]:
b=range(0,stop=2*pi,length=10)
Out[63]:
In [64]:
collect(b)
Out[64]:
In [65]:
A=ones(3)
Out[65]:
In [66]:
A=zeros(3)
Out[66]:
In [67]:
B=randn(5) # loi normale centrée de variance 1
Out[67]:
In [68]:
B=[ones(3,2) zeros(3,2)] # concaténation de tableaux
Out[68]:
In [69]:
B=[ones(3,2); zeros(3,2)] # , ou ; jouent le rôle de retour à la ligne
Out[69]:
In [70]:
C=Diagonal(ones(3,3))
Out[70]:
In [71]:
diag(C) # extraction d'une diagonale
Out[71]:
In [1]:
using SparseArrays
In [3]:
A=spzeros(3,3)
Out[3]:
In [5]:
Out[5]:
In [74]:
A=spdiagm(0 => 1:3)
Out[74]:
In [75]:
A=A+spdiagm(1 => 1:2)
Out[75]:
In [76]:
sparse([0 1 2; 2 0 0]) # pour rendre sparse une matrice "full"
Out[76]:
In [77]:
det(A)
Out[77]:
In [78]:
a=1
b=a
b+=1
Out[78]:
In [79]:
a
Out[79]:
In [80]:
b
Out[80]:
Par contre maintenant si la variable est un tableau
In [81]:
A=collect(1:5)
B=A
B.+=1
Out[81]:
In [82]:
A
Out[82]:
In [83]:
B
Out[83]:
Pour avoir un comportement il faut copier le tableau A
In [84]:
A=collect(1:5)
B=copy(A)
B.+=1
Out[84]:
In [85]:
A
Out[85]:
In [86]:
B
Out[86]: