Pour mener à bien un calcul algorithmique le nombre d'éléments de langage n'est pas très important et peut se résumer aux 3 syntaxes suivantes
Un choix simple si le test est vrai (k==1) alors le bloc d'instruction est évalué
In [1]:
k=1;
if k==1
println("k=1")
end
Le else permet de donner un résultat par défaut...
In [2]:
k=1;
if k!=1
println("k<>1")
else
println("k=1")
end
Une succession de elseif permet de choisir parmi plusieurs critères, dans la succession des blocs de if et elseif le premier qui est "vrai" est évaluer et l'instruction s'arrète.
In [3]:
k=2;
if k==1
println("k=1")
elseif k>1
println("k>1")
else
println("k<1")
end
In [4]:
for i=1:10
println(i)
end
In [5]:
for i in ["un" 2 im]
println(typeof(i))
end
La commande break permet de sortir d'une boucle à tout moment
In [6]:
for i = 1:1000
println(i)
if i >= 5
break
end
end
La commande continue permet elle de courtcircuiter la boucle en court et de passer à la valeur suivante
In [7]:
for i = 1:10
if i % 3 != 0 # i modulo 3 different de 0
continue
end
println(i)
end
In [8]:
k=0;
while k<10
k+=1 # k=k+1
println(k)
end
De même que la boucle for les commandes break et continue sont valables ...
In [9]:
k=0;
while k<1000
k+=1 # k=k+1
if k % 5 != 0 # k modulo 5 diffèrent de 0
continue # retour en début de boucle avec de nouveau un test sur k
end
println(k)
if k>30
break
end
end
In [34]:
start = time()
A=zeros(0);
for i=1:1000000
A=[A;i]; # a chaque itération on change la taille de A
end
elapsed = time() - start
In [32]:
typeof(A)
Out[32]:
In [33]:
A
Out[33]:
In [20]:
start = time()
A=zeros(0);
for i=1:1000000
push!(A,i); # a chaque itération on change la taille de A
end
elapsed = time() - start
Out[20]:
In [16]:
A
Out[16]:
In [24]:
start = time()
A=zeros(Int64,1000000)
for i=1:1000000
A[i]=i;
end
elapsed = time() - start
Out[24]:
In [26]:
start = time()
A=[i for i=1:1000000]
elapsed = time() - start
Out[26]:
In [27]:
typeof(A)
Out[27]:
In [35]:
start = time()
n=3000;
x=range(0,stop=1,length=n);
V=zeros(n,n);
for i=1:n
V[:,i]=x.^(i-1) # calcul vectorisé
end
elapsed = time() - start
Out[35]:
In [42]:
A=rand(3,3)
A[:,1].=1
A
Out[42]:
In [43]:
start = time()
n=3000;
x=range(0,stop=1,length=n);
X=zeros(n,n);
for i=1:n
for j=1:n
X[i,j]=x[i]^(j-1) # calcul dévectorisé
end
end
elapsed = time() - start
Out[43]:
In [ ]:
typeof(X)
In [45]:
start = time()
n=3000;
x=range(0,stop=1,length=n);
W=[x[i]^(j-1) for i=1:n, j=1:n];
elapsed = time() - start
Out[45]:
In [ ]:
typeof(W)
In [46]:
function Vander(n)
x=range(0,stop=1,length=n);
V=zeros(n,n);
for i=1:n
#V[:,i]=x.^(i-1)
for j=1:n
V[i,j]=x[i]^(j-1) # calcul dévectorisé
end
end
return V
end
start = time(); Z=Vander(3000); elapsed = time() - start
Out[46]:
In [47]:
start = time(); Z=Vander(3000); elapsed = time() - start
Out[47]:
In [48]:
start = time(); Z=Vander(3000); elapsed = time() - start
Out[48]:
In [49]:
function Vander2(n)
x=range(0,stop=1,length=n);
[x[i]^(j-1) for i=1:n, j=1:n];
end
start = time(); Z2=Vander2(3000); elapsed = time() - start
Out[49]:
In [50]:
start = time(); Z2=Vander2(3000); elapsed = time() - start
typeof(Z2)
Out[50]:
La conclusion n'est pas toujours évidente a priori... Néanmoins on peut voir que le fait de mettre le code dans une fonction impose une optimisation à la compilation et une contextualisation du type et que l'écriture explicite des boucles donne un meilleur résultat.
In [ ]: