TP0 - (re)prise en main de Scilab

Modélisation, simulation & méthodes numériques

Dans son utilisation la plus simple, Scilab est une "super-calculatrice". Au prompt, ou invite de commande, "-->", on peut saisir des commandes, calculs, … Scilab retourne alors ce qu'il en pense, après "ans =+" (pour answer).
Par exemple, saisir successivement:

-->a=5+12.3
-->sqrt(12)
-->(1+%i)^3

ou encore,

-->A=3;
-->x=[-2*%pi:0.01:2*%pi];
-->y=A*cos(2*x);
-->plot(x,y);

Le point virgule ";" à la fin d'une ligne permet simplement de ne pas afficher la réponse d'une instruction.
On peut aussi saisir les instructions précédentes dans un script. Saisir pour cela la commande "edit" (ou dans la barre de menus, "Applications → SciNotes").
Saisir, ou copier, les lignes précédentes et enregistrer le fichier sous le nom "prog.sce" (téléchargeable ici

). Exécuter enfin ce script, soit à partir de l'icone ad-hoc

de la fenêtre de l'éditeur, soit en tapant dans la fenêtre de commandes de Scilab la commande

-->exec('prog.sce',-1)

Exercice 1

Que calculent les programmes suivants ? Les saisir et les exécuter.

Programme 1:

u=0;n=10;
for i=1:n
    u=2/3*u-1/6
    disp(i,u)
end

Programme 2:

s=0;n=10;
for i=1:n
     s=s+i
end
disp(s)

Calculer pour différentes valeurs de (par exemple, 10, 100, 1000, …) les sommes
$S=1+\dfrac12+\dfrac14\dots+\dfrac1{2^n}$
et
$T=1+\dfrac12+\dfrac13+\dots+\dfrac1n$

Le premier programme calcule successivement les 10 premiers termes de la suite définie par récurrence par et pour tout entier , $u_{n+1}=\dfrac23u_n-\dfrac16$

(on se rappelle bien sûr que la somme des

premiers entiers vaut $1+2+\dots+n=\dfrac{n(n+1)}2$ )

Pour la somme S

n=10;
S=0
for i=0:n
    S=S+1/2^i
end
disp(S)

et pour la somme T

n=100;
T=0
for i=1:n
    T=T+1/i
end
disp(T)

Remarques: La première somme est une somme géométrique dont on sait calculer exactement la somme limite (et on trouve 2).
La deuxième somme est la somme harmonique: on la sait divergente vers +∞.

Pour le premier exemple précédent, programme 1, on peut aussi créer un vecteur (ou matrice, ou encore tableau) contenant les valeurs successives de la suite:

u=0;n=10;
for i=1:n
     V(i)=u
     u=2/3*u-1/6
end
plot(V)

ce qui permet, entre autre, de pourvoir tracer sur un graphique ces valeurs:

V(1)=0;n=10;
for i=1:n
     V(i+1)=2/3*V(i)-1/6
end
plot(V)

Exercice 2

En s'aidant de l'exercice 1 précédent, tracer sur un graphique

les valeurs de la somme en fonction de
les valeurs de la somme en fonction de , et superposer sur ce même graphique la courbe du logarithme népérien (log)
Que remarque-t'on ?
Tracer enfin sur un autre graphique l'évolution de l'écart, en fonction de , entre et .

On peut utiliser le programme précédent calculant les valeurs successives de la somme et simplement socker les valeurs calculées successivement dans une liste V:
```
n=10;
S=1;
for i=1:n
    V(i)=S
    S=S+1/2^i
end
plot(V)
```
De même pour la somme harmonique:
```
n=10;
T=0
for i=1:n
    V(i)=T
    T=T+1/i
end
plot(V)
```
On peut tracer sur ce mêgraphique la courbe du logarithme en ajoutant à la suite des lignes précédentes
```
x=1:n;
y=log(y);
plot(x,y,'r')
```
Le troisième argument 'r' permet de tracer la courbe en rouge, voir ces quelques éléments graphiques.
Les deux courbes semblent avoir une direction asymptotique commune (ou semblent devenir "parallèles" pour des grandes valeurs de n).
Pour préciser les choses, on calcule et trace la différence:
```
n=100;
T=0
for i=1:n
    T=T+1/i
    V(i)=T-log(i)
end
plot(V)
```
Cette différence tend vers une limite. (Cette valeur limite est appelée constante d'Euler).

Exercice 3

Soit la suite définie par

puis, pour tout entier

, $u_{n+1}=ru_n\lp1-u_n\rp$ .

Écrire un programme qui calcule est représente graphiquement les 50 premiers termes de la suite $\left( u_n\rp$ dans les trois cas: , et .
Représenter graphiquement, dans les mêmes trois cas, les termes $u_{950}$ à $u_{1000}$ .

u(1)=0.2;
n=50;
r=3;
for i=1:n
     u(i+1)=r*u(i)*(1-u(i));
end
plot(u)

On modifie bien sûr dans ce programme la valeur de r.

La suite est définie par récurrence et pour connaître un terme quelconque il faut calculer tous les termes successivement. Il faut donc réutiliser le programme précédent. Par contre on ne trace que les 50 derniers termes:
```
u(1)=0.2;
n=1000;
r=3;
for i=1:n
     u(i+1)=r*u(i)*(1-u(i));
end
plot(u(950:1000))
```

Suivant les valeurs, notamment

, on observe un comportement chaotique.

Les programmes précédents utilisent des boucles itératives: on effectue les instructions dans la boucle un nombre fixé de fois (

ici), défini à l'avance.

Les boucles conditionnelles, (while …), permettent d'effectuer des instructions "en boucle" sans nécessairement en connaître le nombre dès le début.
Par exemple, si on cherche le nombre de termes dans la somme

avant de dépasser 10, on peut procéder ainsi:

T=0;i=0;
while T<10
     i=i+1
     T=T+1/i
end
disp(i)

La boucle est effectuée tant qu'on n'a pas atteint 10. La variable i est ici un compteur: on lui ajoutant 1 à chaque boucle (on dit qu'on incrémente la variable).

Exercice 4

Une fine couche d'épaisseur 1cm d'un certain matériau absorbe 5% de l'intensité sonore, en dB, qui la traverse.
Combien de couches, et donc quelle épaisseur, de ce matériau faut-il pour qu'un son d'une intensité de 140 dB soit atténué en moins 40 dB ?
Tracer sur un graphique l'intensité sonore en fonction du nombre de couches traversées.

Chaque couche diminue de 5% l'intensité, c'est-à-dire la multiplie par 0,95.

I=140
n=0
while I>40
    I=I*0.95
    n=n+1
end
disp(n)

et on trouve qu'l faut au moins 25 couches.

Pour tracer l'évolution de l'intensité en fonction du nombre de couches, il faut créer un vecteur contenant les valeurs successives. On modifie le programme précédent:


clear //efface les variables existantes
clf // efface la figure
I=140
n=0
while I>40
    I=I*0.95
    n=n+1
    V(n)=I
end
disp(n)
plot(V)