Introduction à la programmation

sous Scilab :
TP auto-correctifs I

Licence de Physique à distance

Table des matières
I Prise en main de scilab 1
a) Organisation du travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
b) Première utilisation de Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
c) Premier exemple de script Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . 2
d) Premier exemple de fonction Scilab . . . . . . . . . . . . . . . . . . . . . . . . . 3
e) Faire des tests dans Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
f) Aide en ligne et démos Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

II Vecteurs et matrices (I) 6

a) Construction de vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
b) Construction de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
c) Extration de sous-matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

III Graphiques 9
a) Utilisations de plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
b) Un exemple : l’application logistique . . . . . . . . . . . . . . . . . . . . . . . . 9
I Prise en main de scilab 1

I Prise en main de scilab

a) Organisation du travail
L’objectif de cette série d’exercices est de vous permettre d’acquérir les bases du logiciel de calcul
scientifique Scilab, qui vous seront indispensables pour les TP et Devoirs Numériques, notam-
ment en LP341 et LP342. Commencez par créer un dossier (nommé par exemple «SCILAB»)
où seront stockés vos fichiers et données. Chaque exercice demandant une exécution devra faire
l’objet d’un script sous forme d’un fichier texte nommé par exemple «NOM-exo1.sce» (pour
l’exercice 1). Il est important, et très fortement recommandé, de commenter les script par des
lignes (tout ce qui suit un //) qui vous permettront en suite de retrouver plus facilement le
sens des opérations programmées et de comprendre le script sans besoin de revenir en arrière.
D’autre part vous serez peut-être amené à demander conseil à vos enseignants et à leur envoyer
vos script : il faudra donc bien noter votre nom et l’exercice concerné. Le format conseillé d’un
script est le suivant :

//NOM prenom - Exercice 1 – Introduction SCILAB

// Commentaires generaux
// Commentaires generaux
... code ... // commentaire de la ligne
... code ...
//Commentaires generaux
... code ...
... code ...

Ces exercices auto-correctifs ne sont pas corrigés (ni notés) par vos enseignants, mais vous
disposez d’un corrigé détaillé pour chaque exercice, qui vous permettra d’évaluer et corriger
votre travail vous même. Mais il est important d’essayer avant de regarder la solution !

b) Première utilisation de Scilab

Lancer Scilab, soit en cliquant sur l’icone correspondante, soit en executant la commande scilab
dans un terminal, selon les environnements. Une fois lancé, le logiciel se présente sous la forme
d’une fenêtre de commande possédant une barre de menu. L’exercice suivant permet de dé-
couvrir la première utilisation possible de Scilab, en tant que calculatrice scientifique. Pour
le moment, vous pouvez taper les commandes directement dans la fenêtre Scilab, mais rien
n’empêche de les écrire dans un script, tout de suite ou bien dans un deuxième moment, pour
pouvoir les garder et les commenter.

Exercice 1 : Tapez successivement les lignes suivantes, appelées instructions ou commandes,

dans la fenêtre de commande à la suite de la flèche --> (en appuyant sur la touche Enter/Entrée
valider la commande et changer de ligne).

a=5+6
sqrt(12) //Avez-vous compris ce que fait sqrt ?
(1+%i)^3 //Avez-vous compris ce que représente %i ?
// A quoi sert le symbole ^ ?
2

a=[1,2,3], b=[1 2 3] //Que sont a et b ?

cos(a) \\
c=[-1;2;1;-3] //Notez la différence entre ; et ,
A=[1,-1,3,4;-1,2,7,8;0,2,-4,-2]
d=exp(A) e=A*c // Notez que cette opération est effectivement
//autorisée par les dimensions de A et c.

Comme vous le voyez, nous avons rajouté des signes de commentaires (//) avant de mettre
quelques questions additionnelles. Ce genre de commentaires peuvent être utilisés dans votre
script (par exemple pour mettre la réponse à la question posée !) : ils n’auront aucun effet sur
l’exécution de la commande. Essayer par exemple de taper :
sqrt(12) //la fonction sqrt est...

c) Premier exemple de script Scilab

Afin d’exécuter une suite d’instructions plus longue ou plus complexe, il est préférable d’écrire
celles-ci dans un fichier plutôt que de les taper dans la fenêtre de commande comme précédem-
ment. On parle dans ce cas de l’écriture d’un script. Il est ensuite possible d’exécuter ce script
en utilisant la commande exec accessible
– soit avec la barre de menu de la fenêtre principale (à partir du menu principal : File → File
operations → Exec) ;
– soit en tapant exec nom_du_script dans la fenêtre de commande.
Vous disposez un éditeur de texte nommé Scipad ou SciNotes. Pour ouvrir l’éditeur, cliquez sur
le bouton approprié, ou aller dans le menu Applications, ou encore taper edit.

Exercice 2 : Cet exercice propose un premier exemple d’écriture et d’exécution d’un script.
Ouvrez l’éditeur de texte et créez un fichier que vous enregistrerez dans votre dossier sous le
nom essai1.sce contenant le texte suivant :

A=rand(4,4);
b=ones(4,1);
x=inv(A)*b;
s=A*x-b;
x,s

Rappelons que l’on peut aussi exécuter le script à partir de la fenêtre de commande par :
exec(’essai1.sce’).

1) Quelle est la signification des fonctions rand() et ones() ? Ces fonctions sont issues de la
bibliothèque Scilab.

2) Exécuter le script. Commenter les résultats obtenus.

NB : vous devez choisir vous-même les noms de vos scripts Scilab. Les noms ne doivent pas
comporter d’espaces, d’opérateurs mathématiques (+ - / *), ou de signes spéciaux ( : ! ; ,
etc). Par contre, le «underscore» _ est autorisé. Dans tous les cas, vous n’oublierez pas de
préciser l’extension qui est .sce (ou .sci pour les fonctions).
d) Premier exemple de fonction Scilab 3

d) Premier exemple de fonction Scilab

Il est également possible de construire avec Scilab de nouvelles fonctions mathématiques, en
complément de celles existantes (comme sqrt(12) que l’on a vu, ou inv(A) par exemple
pour calculer l’inverse d’une matrice). Ces fonctions peuvent prendre divers types d’arguments
(scalaire, matrice, etc.) et peuvent réaliser des opérations mathématiques plus ou moins com-
plexes. L’exercice suivant propose un premier exemple d’écriture et de chargement d’une fonc-
tion.

Exercice 3 :
Ouvrir l’éditeur Scipad et recopiez ce script :

n=12;
c=1;
for i=1:n
c=c*i;
end

Sauvez le fichier sous le nom titi.sce et exécutez-le. Tapez ensuite c et Enter/Entrée pour
afficher la valeur de la variable c.

1) Que calculent ces quelques lignes de programme ?

2) Est-ce important d’initialiser c à la valeur 1 ?

Modifiez votre script pour englober ces quelques lignes dans une fonction qu’on appellera toto,
prenant comme argument n, et renvoyant la valeur de c :

function c=toto(n)
c=1;
for i=1:n
c=c*i;
end
endfunction

Enregistrer la fonction sous le nom toto.sci. Dans la fenêtre Scilab, appeler la fonction.

3) Que se passe-t-il ? Taper maintenant toto(4) (ou toto(5)...). Que réalise la fonction que
vous venez de créer ? Quelle fonction bien connue reconnaît-on ?

4) Essayez avec toto(-5). Que remarquez-vous ? (On s’occupera de cette question dans la
section suivante).
Pour le moment, un autre exercice simple sur les fonctions :

Exercice 4 : Programmer la fonction f (x) = x2 en utilisant la méthode vue dans l’exercice

précedent. Tester le résultat.
4

e) Faire des tests dans Scilab

Pour effectuer un test, qui conditionnera l’exécution d’une ou plusieurs commande(s) si le
test est vrai, on utilise les commandes if, elseif, else, end. Pour exécuter une ou plusieurs
instruction(s) tant que le test est vrai, on utilise les commandes while, end. Dans tous ces cas,
il faut utiliser une variable booléene, c’est-à-dire une variable qui ne peut que être égale qu’à
vraie (T ou 1) ou fausse (F ou 0). Un test de comparaison crée une variable Bouléenne de valeur
T ou F. Par exemple, taper : 1 < 0.5. Quelle est la réponse ?
Les instructions conditionnées au test sont effectuées si le test est vrai, et ne sont pas effectuées
si le test est faux. Par exemple, on écrira :
if valtest<0.5
instructions 1
else
instructions 2
end
Ici, l’expression valtest<0.5 est une variable booléenne : si valtest est inférieure à 0.5,
cette variable booléenne vaut T, et le programme exécutera les instructions 1. Si valtest est
supérieure ou égale à 0.5, la variable booléenne valtest<0.5 vaut 0 et le programme exécutera
alors les instructions 2.
L’exercice suivant propose d’ajouter un test à la fonction toto définie précédemment pour
s’assurer que la variable n est un entier positif.

Exercice 5 : Un test pour voir si un nombre n est un entier est de regarder si ce nombre est
égal ou non à sa partie entière int(n). On veut s’assurer que le nombre n est un entier positif.
Pour cela, vous allez modifier la fonction toto précédente, de sorte que si n est négatif ou n
n’est pas entier, la fonction toto renvoie la valeur 0, et sinon, toto renvoie la valeur calculée
de c. Modifier la fonction toto.sce puis tester celle-ci sur différentes valeurs en entrée.

f) Aide en ligne et démos Scilab

La prise en main du logiciel passe aussi par la découverte de l’aide en ligne dont le recours
sera ensuite constant. Cette aide, presque exclusivement en anglais, est accessible à partir
de l’option Help du menu ou en tapant la commande help. Elle se présente sous la forme
d’une liste de fichiers d’aide pour chaque instruction disponible sous Scilab. Pour effectuer une
recherche par mot clé dans l’index (par exemple, trouver la fonction qui retourne le cosinus
hyperbolique), on peut taper apropos cosine dans la fenêtre de commande (et découvrir que
la fonction s’appelle cosh). Au contraire, lorsqu’une instruction est connue (par exemple rand),
il est possible d’accéder directement à l’aide sur celle-ci entapant help rand sur la ligne de
commande.

Exercice 6 : On veut écrire de plusieurs manières un script qui calcule la somme des n premiers
entiers : 1 + 2 + 3 + 4 + ... + n
1) Ecrire un script qui permet le calcul de la somme à l’aide d’une boucle for.
2) Même question avec une boucle while.
3) Ecrire une fonction sommetheorique qui renvoie la formule mathématique n*(n+1)/2.
4) Cette formule coïncide-t-elle avec la somme des n premiers entiers ?
II Vecteurs et matrices (I) 5

II Vecteurs et matrices (I)

Dans cette partie, l’accent est mis sur les différentes possibilités de construction et de manipu-
lation de vecteurs et de matrices.

a) Construction de vecteurs
On dispose de différentes possibilités de construire un vecteur (appelév par la suite) :
– Lorsque la taille du vecteur est connue et est petite, on peut écrire directement le vecteur,
par exemple v=[1,2] pour un vecteur ligne et v=[1;2] pour un vecteur colonne.
– Lorsque les valeurs du vecteur suivent une progression arithmétique, en écrivant par exemple
v=2:0.1:4. Dans cet exemple, 2 est le premier terme de la suite et 0.1 sa raison (par défaut,
la raison est égale à un). Le dernier paramètre (ici 4) ne fait pas toujours partie de la suite,
comme dans l’exemple v=2:0.3:4 (essayer !).
– En utilisant une boucle for. Par exemple, la boucle

for k=1:4,
v(k)=k*k;
end

crée un vecteur v de dimension 4.

Remarque : Il est recommandé d’initialiser les vecteurs de grande dimension (avec l’instruction
zeros ou ones, par exemple) pour économiser les temps de réallocation de la mémoire vive
lors de calculs longs.
– En initialisant v comme un vecteur vide : v=[], puis en utilisant une boucle for pour «con-
caténer» de nouveaux éléments à v :

for k=1:4,
v=[v,k*k];
end

– En effectuant des fonctions scilab comme rand, zeros, ou one :

u=rand(3,1);
v=ones(3,1);

– En effectuant des opérations de somme, de multiplication et de division matricielle à partir

de vecteurs déjà définies :
– En utilisant la fonction linspace. Voir l’aide de cette commande.
On accède à un élément du vecteur u de dimension n par u(k) où k est un entier compris entre
1 et n.
On peut également accéder à une partie d’un tableau u en utilisant un tableau d’indice. Par
exemple, on accède aux éléments 5 à 10 du tableau u en tapant : u(5:10)

Exercice 7 : Tapez les instructions suivantes et en commenter les résultats :

n=5, u=rand(n,1), u(3), u(2:n-1), u($), u’, length(u)
6

Exercice 8 : Construire le vecteur ligne de taille n qui comporte les carrés des n premiers
nombres entiers. (choisir n=8 par exemple).

Exercice 9 : Construire un vecteur de taille 10 dont la composante i est égale à (−1)i .

b) Construction de matrices
Les vecteurs étant pour Scilab des cas particuliers de matrices de taille n × 1 ou 1 × n, il est
naturel que la construction d’une matrice A s’effectue de manière similaire à celle d’un vecteur,
en l’occurrence :
– Lorsque la taille de la matrice est connue et petite, en écrivant par exemple A=[1,2,3; 3,4,5]
pour une matrice de taille 2 × 3 ;
– En initialisant A à la matrice nulle (ou à la matrice identité avec eye) puis en effectuant une
double boucle sur les indices avec des affectations du type A(i,j)=2 ;
– En initialisant A à un vecteur ligne (ou colonne) puis en concaténant dans une boucle chaque
nouvelle ligne (ou colonne) avec des affectations du type A=[A;v] (respectivement A=[A,v]).
A noter que cette méthode s’étend à la concaténation entre matrices ;
– En effectuant des opérations de somme, de multiplication et de division matricielle à partir
de matrices déjà définies :
u=rand(3,2); v=rand(3,2); 2*u-3*v, u*v’
– En effectuant des opérations composante par composante (utiliser les opérations .*, ./ ou
.^) à partir de vecteurs ou matrices déjà définis :
u.*v, u./v, u.^v
Remarque : si on veut construire le vecteur 1/v il faut utiliser la commande Id./v ou bien
v^(-1). (Sur les versions récentes, 1./v marche aussi.)
On accède à un élément de la matrice A de dimension m×n, c’est-à-dire à m lignes et n colonnes,
par A(i,j) où i est une entier compris entre 1 et m et j est un entier compris entre 1 et n.

Exercice 10 : Reconstruire le vecteur ligne de taille n qui comporte les carrés des n premiers
nombres entiers sans utiliser de boucle cette fois.

Exercice 11 : Tapez les instructions suivantes et en commenter les résultats :

m=5; n=4;
for i=1:m
for j=1:n
A(i,j)=i-j;
end
end
A, size(A), length(A),
u=A(3,:), size(u)
v=A(:), size(v), length(v)

Exercice 12 : Construire la matrice de taille 9 × 9 dont tous les éléments sont nuls sauf les
éléments du «centre» (i, j) = {4, 5, 6}×{4, 5, 6} et les éléments du «bord », i ={1, 9}
ou j = {1, 9}, qui tous valent 1.
c) Extration de sous-matrices 7

Exercice 13 :
1) Construire sans effectuer de boucle la matrice 10 × 10 donnant les résultats de la table de
multiplication de 1 à 10.
2) Construire une matrice de taille m × n dont la composante (i, j) est égale à u(i)v(j) où
u est un vecteur de taille m et v un vecteur de taille n que vous choisirez.

Exercice 14 : Tapez les instructions suivantes et en commenter les résultats :

u=ones(1,5);v=rand(u);
A=[u;2*u;-u], A=[A; v],
B=v’*u, C=B(2:4,3:4)

Exercice 15 : A partir des vecteurs u=[0,0.25,0.5,1] et v=(0:10)/10, construire une ma-

trice X de taille 4 × 10 dont la ligne i est formée de u(i) et une matrice Y dont la colonne j
est formée de v(j).

c) Extration de sous-matrices
Il est possible d’extraire facilement avec Scilab une sous matrice d’une matrice quelconque
simplement en construisant le vecteur formé par les indices de lignes et celui formé par les
indices de colonnes à sélectionner. Par exemple, l’instruction B=A(1:2:5,1:3) extraira de la
matrice A les lignes 1,3 et 5 et les colonnes 1,2 et 3 pour former une matrice 3 × 3. Ainsi une
matrice 5 × 5 formée de 1 sur ses colonnes impaires s’écrit :
A=zeros(5,5); A(:,[1,3,5])=1
et une matrice 6 × 6 formée de 2 blocs carrés de 3 × 3 ne contenant que des 1 :
A=zeros(6,6); A(1:3,1:3)=1; A(4:6,4:6)=1

Exercice 16 : Tester ces extractions.

8

III Graphiques
a) Utilisations de plot
Scilab permet d’effectuer des représentations graphiques évoluées de courbes, de surfaces, de
lignes de niveau à partir de données matricielles. Les instructions correspondantes (plot,
plot3d, contour, etc.) possèdent une syntaxe très proche (détaillée dans l’aide de plot).
On peut ajouter ou modifier un certain nombre de paramètres du graphique.
– les couleurs et ou les symboles, avec des notations du genre plot(x,y,’+r’) (pour avoir des
croix en couleur rouge) ;
– spécifier le titre du graphe et les labels des axes avec xtitle ;
– Utiliser une échelle logaritmique ;
– Tracer des histogrammes...

Exercice 16 : On veut tracer une fonction simple comme par exemple x(t) = sin(t) entre −2π
et 2π, en faisant apparaître sur les axes les noms des variables, dans ce cas, par exemple, t et x.

1) Définir le vecteur t allant de −2π à2π avec un pas de 0.1.

2) En déduire le vecteur x égale à sin(t). Vérifier que ces deux vecteurs corréspondent bien à
ce qu’on veut tracer.

3) Tracer x(t) en rouge, ligne continue plus symboles, en utilisant la fonction plot, puis nommer
les axes et donner un titre au plot par la commande xtitle.

Exercice 17 : Tracer, sur un même graphe (il suffit de les tracer une après l’autre), les deux
fonctions x(t) = sin(t)/t et y(t) = 1/t entre 0.1 et 30, en deux couleurs différentes. Utiliser l’outil
Zone de Zoom dans la fenêtre graphique pour agrandir la partie qui vous semble intéressante.

b) Un exemple : l’application logistique

Dans cette partie de l’initiation, l’accent est mis sur les potentialités graphiques Scilab à travers
le problème de l’application logistique. Il s’agit d’un grand classique de la physique du chaos,
c’est un problème qui ne nécessite pas de connaissances particulières en méthodes numériques et
qui présente un certain aspect ludique, ce qui en fait un bon exemple d’une façon de procéder.

Exercice 18 : Multiplication des insectes

Imaginons une population, par exemple, d’insectes, comportant à la génération p, zp individus.
Si chaque individu donne lieu, en moyenne, à α insectes à la génération suivante (par exemple
en pondant α oeufs, pour mourir ensuite), celle-ci comportera zp+1 = αzp individus. Évidem-
ment, si α > 1, la population d’insectes diverge exponentiellement, une perspective sans doute
quelque peu effrayante mais qui ne tient pas compte des ressources disponibles, la nourriture en
particulier : plus les insectes sont nombreux, plus les ressources deviennent rares pour chaque
insecte qui aura donc plus de difficultés à s’assurer une descendance. Le coefficient α doit alors
décroître lorsque le nombre d’insectes augmente ; on peut alors prendre l’expression linéairement
décroissante (c’est le plus simple) suivante :
zp
α = r(1 − ) (1)
ζ
b) Un exemple : l’application logistique 9

où ζ est le nombre d’insectes qui épuise toutes les ressources au point de ne pas pouvoir donner
lieu à une génération suivante... Cela donne :
zp
zp+1 = rzp (1 − ). (2)
ζ

On peut réécrire cette équation en prenant comme variable xp = zp /ζ 0 < xp < 1, et on a

xp+1 = rxp (1 − xp ) , (3)

ce qui constitue l’équation logistique. Il s’agit donc de déterminer comment se comportera la

population d’insectes en fonction du paramètre r.
Un programme permettant de simuler l’évolution temporelle de la population d’insectes peut
avoir la forme suivante :

n=1000; //nombre de génération de la population

x=zeros(1:n); //initialisation
r=2;
x(1)=0.2; //condition initiale
// évolution temporelle à l’aide d’une boucle for

1) Écrire la boucle temporelle manquante dans le script ci-dessus.

2) Représenter sur un graphique l’évolution de la population pour r = 2 sur l’intervalle [0,50],
c’est-à- dire sur 50 générations. Pour cela, on utilisera l’aide Scilab et les arguments de plot.
3) Ajouter les graphes pour r = 3, r = 3.5 et r = 4 au graphe précédent.
4) Changer la couleur des courbes (rouge, bleu, etc.) ainsi que la style des tracés en mettant
des symboles + pour l’une des courbes, des pointillés pour une autre.
5) Donner un titre au graphe et des labels aux axes.
La commande scf(a) permet d’ouvrir une nouvelle fenêtre graphique de numéro a (par défaut,
la première fenêtre qui s’ouvre avec la commande plot est de numéro 0). Lorsque plusieurs
fenêtres sont ouvertes, cette commande permet de se placer dans la fenêtre numéro a pour
tracer (par défaut Scilab trace le graphe demandé dans la dernière fenêtre ouverte).
6) Tracer les graphes dans quatre fenêtres différentes, prendre n=[950-1000] pour les trois
derniers graphes.
7) Les points fixes Existe-t-il des solutions stationnaires telles que xp+1 = xp ? Déterminez
les, et discutez leur validité.
8) Tracer la courbe qui donne la valeur du point fixe en fonction de r variant de 1 à 4 par pas
de 0.1.
9) A la vue du graphe tracé précédemment, que vaut le point fixe pour r = 2 ? Pouvait-on le
dire d’après le graphe tracé à l’exercice 1 ? Que se passe-t-il pour r = 3, 3.5 et 4 ?